x/swift3
Code Issues Proposed changes

Use assertEqual instead of assertEquals

Browse Source 
As assertEquals is the deprecated form of assertEqual
it is recommended to use assertEqual

Change-Id: I8851dba28f128e84607566e2424e7d6260e7eb82
This commit is contained in:
Gábor Antal 2016-02-26 12:31:20 +01:00
parent 4336ff4f99
commit 5cf3346e57
25 changed files with 951 additions and 948 deletions

2
swift3/test/functional/__init__.py

@ -47,4 +47,4 @@ class Swift3FunctionalTestCase(unittest.TestCase):
# self.assertTrue(headers['server'] is not None)
if etag is not None:
self.assertTrue('etag' in headers) # sanity
self.assertEquals(etag, headers['etag'].strip('"'))
self.assertEqual(etag, headers['etag'].strip('"'))

38
swift3/test/functional/test_acl.py

@ -40,39 +40,39 @@ class TestSwift3Acl(Swift3FunctionalTestCase):
status, headers, body = \
self.conn.make_request('PUT', self.bucket, headers=headers,
query=query)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
self.assertEquals(headers['content-length'], '0')
self.assertEqual(headers['content-length'], '0')
# GET Bucket ACL
status, headers, body = \
self.conn.make_request('GET', self.bucket, query=query)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
# TODO: Fix the response that last-modified must be in the response.
# self.assertTrue(headers['last-modified'] is not None)
self.assertEquals(headers['content-length'], str(len(body)))
self.assertEqual(headers['content-length'], str(len(body)))
self.assertTrue(headers['content-type'] is not None)
elem = fromstring(body, 'AccessControlPolicy')
owner = elem.find('Owner')
self.assertEquals(owner.find('ID').text, self.conn.user_id)
self.assertEquals(owner.find('DisplayName').text, self.conn.user_id)
self.assertEqual(owner.find('ID').text, self.conn.user_id)
self.assertEqual(owner.find('DisplayName').text, self.conn.user_id)
acl = elem.find('AccessControlList')
self.assertTrue(acl.find('Grant') is not None)
# GET Object ACL
status, headers, body = \
self.conn.make_request('GET', self.bucket, self.obj, query=query)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
# TODO: Fix the response that last-modified must be in the response.
# self.assertTrue(headers['last-modified'] is not None)
self.assertEquals(headers['content-length'], str(len(body)))
self.assertEqual(headers['content-length'], str(len(body)))
self.assertTrue(headers['content-type'] is not None)
elem = fromstring(body, 'AccessControlPolicy')
owner = elem.find('Owner')
self.assertEquals(owner.find('ID').text, self.conn.user_id)
self.assertEquals(owner.find('DisplayName').text, self.conn.user_id)
self.assertEqual(owner.find('ID').text, self.conn.user_id)
self.assertEqual(owner.find('DisplayName').text, self.conn.user_id)
acl = elem.find('AccessControlList')
self.assertTrue(acl.find('Grant') is not None)
@ -82,31 +82,31 @@ class TestSwift3Acl(Swift3FunctionalTestCase):
status, headers, body = \
aws_error_conn.make_request('PUT', self.bucket,
headers=req_headers, query='acl')
self.assertEquals(get_error_code(body), 'SignatureDoesNotMatch')
self.assertEqual(get_error_code(body), 'SignatureDoesNotMatch')
status, headers, body = \
self.conn.make_request('PUT', 'nothing',
headers=req_headers, query='acl')
self.assertEquals(get_error_code(body), 'NoSuchBucket')
self.assertEqual(get_error_code(body), 'NoSuchBucket')
status, headers, body = \
self.conn2.make_request('PUT', self.bucket,
headers=req_headers, query='acl')
self.assertEquals(get_error_code(body), 'AccessDenied')
self.assertEqual(get_error_code(body), 'AccessDenied')
def test_get_bucket_acl_error(self):
aws_error_conn = Connection(aws_secret_key='invalid')
status, headers, body = \
aws_error_conn.make_request('GET', self.bucket, query='acl')
self.assertEquals(get_error_code(body), 'SignatureDoesNotMatch')
self.assertEqual(get_error_code(body), 'SignatureDoesNotMatch')
status, headers, body = \
self.conn.make_request('GET', 'nothing', query='acl')
self.assertEquals(get_error_code(body), 'NoSuchBucket')
self.assertEqual(get_error_code(body), 'NoSuchBucket')
status, headers, body = \
self.conn2.make_request('GET', self.bucket, query='acl')
self.assertEquals(get_error_code(body), 'AccessDenied')
self.assertEqual(get_error_code(body), 'AccessDenied')
def test_get_object_acl_error(self):
self.conn.make_request('PUT', self.bucket, self.obj)
@ -115,15 +115,15 @@ class TestSwift3Acl(Swift3FunctionalTestCase):
status, headers, body = \
aws_error_conn.make_request('GET', self.bucket, self.obj,
query='acl')
self.assertEquals(get_error_code(body), 'SignatureDoesNotMatch')
self.assertEqual(get_error_code(body), 'SignatureDoesNotMatch')
status, headers, body = \
self.conn.make_request('GET', self.bucket, 'nothing', query='acl')
self.assertEquals(get_error_code(body), 'NoSuchKey')
self.assertEqual(get_error_code(body), 'NoSuchKey')
status, headers, body = \
self.conn2.make_request('GET', self.bucket, self.obj, query='acl')
self.assertEquals(get_error_code(body), 'AccessDenied')
self.assertEqual(get_error_code(body), 'AccessDenied')
@unittest.skipIf(os.environ['AUTH'] == 'tempauth',

126
swift3/test/functional/test_bucket.py

@ -37,48 +37,48 @@ class TestSwift3Bucket(Swift3FunctionalTestCase):
# PUT Bucket
status, headers, body = self.conn.make_request('PUT', bucket)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
self.assertEquals(headers['location'], '/' + bucket)
self.assertEquals(headers['content-length'], '0')
self.assertEqual(headers['location'], '/' + bucket)
self.assertEqual(headers['content-length'], '0')
# GET Bucket(Without Object)
status, headers, body = self.conn.make_request('GET', bucket)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
self.assertTrue(headers['content-type'] is not None)
self.assertEquals(headers['content-length'], str(len(body)))
self.assertEqual(headers['content-length'], str(len(body)))
# TODO; requires consideration
# self.assertEquasl(headers['transfer-encoding'], 'chunked')
elem = fromstring(body, 'ListBucketResult')
self.assertEquals(elem.find('Name').text, bucket)
self.assertEquals(elem.find('Prefix').text, None)
self.assertEquals(elem.find('Marker').text, None)
self.assertEquals(elem.find('MaxKeys').text,
str(CONF.max_bucket_listing))
self.assertEquals(elem.find('IsTruncated').text, 'false')
self.assertEqual(elem.find('Name').text, bucket)
self.assertEqual(elem.find('Prefix').text, None)
self.assertEqual(elem.find('Marker').text, None)
self.assertEqual(elem.find('MaxKeys').text,
str(CONF.max_bucket_listing))
self.assertEqual(elem.find('IsTruncated').text, 'false')
objects = elem.findall('./Contents')
self.assertEquals(list(objects), [])
self.assertEqual(list(objects), [])
# GET Bucket(With Object)
req_objects = ('object', 'object2')
for obj in req_objects:
self.conn.make_request('PUT', bucket, obj)
status, headers, body = self.conn.make_request('GET', bucket)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
elem = fromstring(body, 'ListBucketResult')
self.assertEquals(elem.find('Name').text, bucket)
self.assertEquals(elem.find('Prefix').text, None)
self.assertEquals(elem.find('Marker').text, None)
self.assertEquals(elem.find('MaxKeys').text,
str(CONF.max_bucket_listing))
self.assertEquals(elem.find('IsTruncated').text, 'false')
self.assertEqual(elem.find('Name').text, bucket)
self.assertEqual(elem.find('Prefix').text, None)
self.assertEqual(elem.find('Marker').text, None)
self.assertEqual(elem.find('MaxKeys').text,
str(CONF.max_bucket_listing))
self.assertEqual(elem.find('IsTruncated').text, 'false')
resp_objects = elem.findall('./Contents')
self.assertEquals(len(list(resp_objects)), 2)
self.assertEqual(len(list(resp_objects)), 2)
for o in resp_objects:
self.assertTrue(o.find('Key').text in req_objects)
self.assertTrue(o.find('LastModified').text is not None)
@ -94,11 +94,11 @@ class TestSwift3Bucket(Swift3FunctionalTestCase):
# HEAD Bucket
status, headers, body = self.conn.make_request('HEAD', bucket)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
self.assertTrue(headers['content-type'] is not None)
self.assertEquals(headers['content-length'], str(len(body)))
self.assertEqual(headers['content-length'], str(len(body)))
# TODO; requires consideration
# self.assertEquasl(headers['transfer-encoding'], 'chunked')
@ -106,43 +106,43 @@ class TestSwift3Bucket(Swift3FunctionalTestCase):
for obj in req_objects:
self.conn.make_request('DELETE', bucket, obj)
status, headers, body = self.conn.make_request('DELETE', bucket)
self.assertEquals(status, 204)
self.assertEqual(status, 204)
self.assertCommonResponseHeaders(headers)
def test_put_bucket_error(self):
status, headers, body = \
self.conn.make_request('PUT', 'bucket+invalid')
self.assertEquals(get_error_code(body), 'InvalidBucketName')
self.assertEqual(get_error_code(body), 'InvalidBucketName')
auth_error_conn = Connection(aws_secret_key='invalid')
status, headers, body = auth_error_conn.make_request('PUT', 'bucket')
self.assertEquals(get_error_code(body), 'SignatureDoesNotMatch')
self.assertEqual(get_error_code(body), 'SignatureDoesNotMatch')
self.conn.make_request('PUT', 'bucket')
status, headers, body = self.conn.make_request('PUT', 'bucket')
self.assertEquals(get_error_code(body), 'BucketAlreadyExists')
self.assertEqual(get_error_code(body), 'BucketAlreadyExists')
def test_put_bucket_with_LocationConstraint(self):
bucket = 'bucket'
xml = self._gen_location_xml('US')
status, headers, body = \
self.conn.make_request('PUT', bucket, body=xml)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
def test_get_bucket_error(self):
self.conn.make_request('PUT', 'bucket')
status, headers, body = \
self.conn.make_request('GET', 'bucket+invalid')
self.assertEquals(get_error_code(body), 'InvalidBucketName')
self.assertEqual(get_error_code(body), 'InvalidBucketName')
auth_error_conn = Connection(aws_secret_key='invalid')
status, headers, body = auth_error_conn.make_request('GET', 'bucket')
self.assertEquals(get_error_code(body), 'SignatureDoesNotMatch')
self.assertEqual(get_error_code(body), 'SignatureDoesNotMatch')
status, headers, body = self.conn.make_request('GET', 'nothing')
self.assertEquals(get_error_code(body), 'NoSuchBucket')
self.assertEqual(get_error_code(body), 'NoSuchBucket')
def _prepare_test_get_bucket(self, bucket, objects):
self.conn.make_request('PUT', bucket)
@ -161,27 +161,27 @@ class TestSwift3Bucket(Swift3FunctionalTestCase):
expect_prefixes = ('dir/', 'subdir/', 'subdir2/')
status, headers, body = \
self.conn.make_request('GET', bucket, query=query)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
elem = fromstring(body, 'ListBucketResult')
self.assertEquals(elem.find('Delimiter').text, delimiter)
self.assertEqual(elem.find('Delimiter').text, delimiter)
resp_objects = elem.findall('./Contents')
self.assertEquals(len(list(resp_objects)), len(expect_objects))
self.assertEqual(len(list(resp_objects)), len(expect_objects))
for i, o in enumerate(resp_objects):
self.assertEquals(o.find('Key').text, expect_objects[i])
self.assertEqual(o.find('Key').text, expect_objects[i])
self.assertTrue(o.find('LastModified').text is not None)
self.assertRegexpMatches(
o.find('LastModified').text,
r'^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$')
self.assertTrue(o.find('ETag').text is not None)
self.assertTrue(o.find('Size').text is not None)
self.assertEquals(o.find('StorageClass').text, 'STANDARD')
self.assertEqual(o.find('StorageClass').text, 'STANDARD')
self.assertTrue(o.find('Owner/ID').text, self.conn.user_id)
self.assertTrue(o.find('Owner/DisplayName').text,
self.conn.user_id)
resp_prefixes = elem.findall('CommonPrefixes')
self.assertEquals(len(resp_prefixes), len(expect_prefixes))
self.assertEqual(len(resp_prefixes), len(expect_prefixes))
for i, p in enumerate(resp_prefixes):
self.assertEquals(p.find('./Prefix').text, expect_prefixes[i])
self.assertEqual(p.find('./Prefix').text, expect_prefixes[i])
def test_get_bucket_with_encoding_type(self):
bucket = 'bucket'
@ -192,9 +192,9 @@ class TestSwift3Bucket(Swift3FunctionalTestCase):
query = 'encoding-type=%s' % encoding_type
status, headers, body = \
self.conn.make_request('GET', bucket, query=query)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
elem = fromstring(body, 'ListBucketResult')
self.assertEquals(elem.find('EncodingType').text, encoding_type)
self.assertEqual(elem.find('EncodingType').text, encoding_type)
def test_get_bucket_with_marker(self):
bucket = 'bucket'
@ -207,20 +207,20 @@ class TestSwift3Bucket(Swift3FunctionalTestCase):
expect_objects = ('object2', 'subdir/object', 'subdir2/object')
status, headers, body = \
self.conn.make_request('GET', bucket, query=query)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
elem = fromstring(body, 'ListBucketResult')
self.assertEquals(elem.find('Marker').text, marker)
self.assertEqual(elem.find('Marker').text, marker)
resp_objects = elem.findall('./Contents')
self.assertEquals(len(list(resp_objects)), len(expect_objects))
self.assertEqual(len(list(resp_objects)), len(expect_objects))
for i, o in enumerate(resp_objects):
self.assertEquals(o.find('Key').text, expect_objects[i])
self.assertEqual(o.find('Key').text, expect_objects[i])
self.assertTrue(o.find('LastModified').text is not None)
self.assertRegexpMatches(
o.find('LastModified').text,
r'^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$')
self.assertTrue(o.find('ETag').text is not None)
self.assertTrue(o.find('Size').text is not None)
self.assertEquals(o.find('StorageClass').text, 'STANDARD')
self.assertEqual(o.find('StorageClass').text, 'STANDARD')
self.assertTrue(o.find('Owner/ID').text, self.conn.user_id)
self.assertTrue(o.find('Owner/DisplayName').text,
self.conn.user_id)
@ -236,20 +236,20 @@ class TestSwift3Bucket(Swift3FunctionalTestCase):
expect_objects = ('dir/subdir/object', 'object')
status, headers, body = \
self.conn.make_request('GET', bucket, query=query)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
elem = fromstring(body, 'ListBucketResult')
self.assertEquals(elem.find('MaxKeys').text, max_keys)
self.assertEqual(elem.find('MaxKeys').text, max_keys)
resp_objects = elem.findall('./Contents')
self.assertEquals(len(list(resp_objects)), len(expect_objects))
self.assertEqual(len(list(resp_objects)), len(expect_objects))
for i, o in enumerate(resp_objects):
self.assertEquals(o.find('Key').text, expect_objects[i])
self.assertEqual(o.find('Key').text, expect_objects[i])
self.assertTrue(o.find('LastModified').text is not None)
self.assertRegexpMatches(
o.find('LastModified').text,
r'^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$')
self.assertTrue(o.find('ETag').text is not None)
self.assertTrue(o.find('Size').text is not None)
self.assertEquals(o.find('StorageClass').text, 'STANDARD')
self.assertEqual(o.find('StorageClass').text, 'STANDARD')
self.assertTrue(o.find('Owner/ID').text, self.conn.user_id)
self.assertTrue(o.find('Owner/DisplayName').text,
self.conn.user_id)
@ -265,20 +265,20 @@ class TestSwift3Bucket(Swift3FunctionalTestCase):
expect_objects = ('object', 'object2')
status, headers, body = \
self.conn.make_request('GET', bucket, query=query)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
elem = fromstring(body, 'ListBucketResult')
self.assertEquals(elem.find('Prefix').text, prefix)
self.assertEqual(elem.find('Prefix').text, prefix)
resp_objects = elem.findall('./Contents')
self.assertEquals(len(list(resp_objects)), len(expect_objects))
self.assertEqual(len(list(resp_objects)), len(expect_objects))
for i, o in enumerate(resp_objects):
self.assertEquals(o.find('Key').text, expect_objects[i])
self.assertEqual(o.find('Key').text, expect_objects[i])
self.assertTrue(o.find('LastModified').text is not None)
self.assertRegexpMatches(
o.find('LastModified').text,
r'^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$')
self.assertTrue(o.find('ETag').text is not None)
self.assertTrue(o.find('Size').text is not None)
self.assertEquals(o.find('StorageClass').text, 'STANDARD')
self.assertEqual(o.find('StorageClass').text, 'STANDARD')
self.assertTrue(o.find('Owner/ID').text, self.conn.user_id)
self.assertTrue(o.find('Owner/DisplayName').text,
self.conn.user_id)
@ -288,31 +288,31 @@ class TestSwift3Bucket(Swift3FunctionalTestCase):
status, headers, body = \
self.conn.make_request('HEAD', 'bucket+invalid')
self.assertEquals(status, 400)
self.assertEquals(body, '') # sanifty
self.assertEqual(status, 400)
self.assertEqual(body, '') # sanifty
auth_error_conn = Connection(aws_secret_key='invalid')
status, headers, body = \
auth_error_conn.make_request('HEAD', 'bucket')
self.assertEquals(status, 403)
self.assertEquals(body, '') # sanifty
self.assertEqual(status, 403)
self.assertEqual(body, '') # sanifty
status, headers, body = self.conn.make_request('HEAD', 'nothing')
self.assertEquals(status, 404)
self.assertEquals(body, '') # sanifty
self.assertEqual(status, 404)
self.assertEqual(body, '') # sanifty
def test_delete_bucket_error(self):
status, headers, body = \
self.conn.make_request('DELETE', 'bucket+invalid')
self.assertEquals(get_error_code(body), 'InvalidBucketName')
self.assertEqual(get_error_code(body), 'InvalidBucketName')
auth_error_conn = Connection(aws_secret_key='invalid')
status, headers, body = \
auth_error_conn.make_request('DELETE', 'bucket')
self.assertEquals(get_error_code(body), 'SignatureDoesNotMatch')
self.assertEqual(get_error_code(body), 'SignatureDoesNotMatch')
status, headers, body = self.conn.make_request('DELETE', 'bucket')
self.assertEquals(get_error_code(body), 'NoSuchBucket')
self.assertEqual(get_error_code(body), 'NoSuchBucket')
def test_bucket_invalid_method_error(self):
# non existed verb in the controller

38
swift3/test/functional/test_multi_delete.py

@ -64,13 +64,13 @@ class TestSwift3MultiDelete(Swift3FunctionalTestCase):
self.conn.make_request('POST', bucket, body=xml,
headers={'Content-MD5': content_md5},
query=query)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
self.assertTrue(headers['content-type'] is not None)
self.assertEquals(headers['content-length'], str(len(body)))
self.assertEqual(headers['content-length'], str(len(body)))
elem = fromstring(body)
resp_objects = elem.findall('Deleted')
self.assertEquals(len(resp_objects), len(req_objects))
self.assertEqual(len(resp_objects), len(req_objects))
for o in resp_objects:
self.assertTrue(o.find('Key').text in req_objects)
@ -82,10 +82,10 @@ class TestSwift3MultiDelete(Swift3FunctionalTestCase):
self.conn.make_request('POST', bucket, body=xml,
headers={'Content-MD5': content_md5},
query=query)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
elem = fromstring(body, 'DeleteResult')
resp_objects = elem.findall('Deleted')
self.assertEquals(len(resp_objects), len(req_objects))
self.assertEqual(len(resp_objects), len(req_objects))
for o in resp_objects:
self.assertTrue(o.find('Key').text in req_objects)
@ -97,11 +97,11 @@ class TestSwift3MultiDelete(Swift3FunctionalTestCase):
self.conn.make_request('POST', bucket, body=xml,
headers={'Content-MD5': content_md5},
query=query)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
elem = fromstring(body, 'DeleteResult')
resp_objects = elem.findall('Deleted')
# S3 assumes a NoSuchKey object as deleted.
self.assertEquals(len(resp_objects), len(req_objects))
self.assertEqual(len(resp_objects), len(req_objects))
for o in resp_objects:
self.assertTrue(o.find('Key').text in req_objects)
@ -113,10 +113,10 @@ class TestSwift3MultiDelete(Swift3FunctionalTestCase):
self.conn.make_request('POST', bucket, body=xml,
headers={'Content-MD5': content_md5},
query=query)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
elem = fromstring(body, 'DeleteResult')
resp_objects = elem.findall('Deleted')
self.assertEquals(len(resp_objects), len(req_objects))
self.assertEqual(len(resp_objects), len(req_objects))
for o in resp_objects:
self.assertTrue(o.find('Key').text in req_objects)
@ -135,13 +135,13 @@ class TestSwift3MultiDelete(Swift3FunctionalTestCase):
'Content-MD5': content_md5
},
query=query)
self.assertEquals(get_error_code(body), 'SignatureDoesNotMatch')
self.assertEqual(get_error_code(body), 'SignatureDoesNotMatch')
status, headers, body = \
self.conn.make_request('POST', 'nothing', body=xml,
headers={'Content-MD5': content_md5},
query=query)
self.assertEquals(get_error_code(body), 'NoSuchBucket')
self.assertEqual(get_error_code(body), 'NoSuchBucket')
# without Object tag
xml = self._gen_invalid_multi_delete_xml()
@ -150,7 +150,7 @@ class TestSwift3MultiDelete(Swift3FunctionalTestCase):
self.conn.make_request('POST', bucket, body=xml,
headers={'Content-MD5': content_md5},
query=query)
self.assertEquals(get_error_code(body), 'MalformedXML')
self.assertEqual(get_error_code(body), 'MalformedXML')
# without value of Key tag
xml = self._gen_invalid_multi_delete_xml(hasObjectTag=True)
@ -159,7 +159,7 @@ class TestSwift3MultiDelete(Swift3FunctionalTestCase):
self.conn.make_request('POST', bucket, body=xml,
headers={'Content-MD5': content_md5},
query=query)
self.assertEquals(get_error_code(body), 'UserKeyMustBeSpecified')
self.assertEqual(get_error_code(body), 'UserKeyMustBeSpecified')
# specified number of objects are over CONF.max_multi_delete_objects
# (Default 1000), but xml size is smaller than 61365 bytes.
@ -171,7 +171,7 @@ class TestSwift3MultiDelete(Swift3FunctionalTestCase):
self.conn.make_request('POST', bucket, body=xml,
headers={'Content-MD5': content_md5},
query=query)
self.assertEquals(get_error_code(body), 'MalformedXML')
self.assertEqual(get_error_code(body), 'MalformedXML')
# specified xml size is over 61365 bytes, but number of objects are
# smaller than CONF.max_multi_delete_objects.
@ -184,7 +184,7 @@ class TestSwift3MultiDelete(Swift3FunctionalTestCase):
self.conn.make_request('POST', bucket, body=xml,
headers={'Content-MD5': content_md5},
query=query)
self.assertEquals(get_error_code(body), 'MalformedXML')
self.assertEqual(get_error_code(body), 'MalformedXML')
def test_delete_multi_objects_with_quiet(self):
bucket = 'bucket'
@ -200,10 +200,10 @@ class TestSwift3MultiDelete(Swift3FunctionalTestCase):
self.conn.make_request('POST', bucket, body=xml,
headers={'Content-MD5': content_md5},
query=query)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
elem = fromstring(body, 'DeleteResult')
resp_objects = elem.findall('Deleted')
self.assertEquals(len(resp_objects), 0)
self.assertEqual(len(resp_objects), 0)
# with Quiet false
quiet = 'false'
@ -214,10 +214,10 @@ class TestSwift3MultiDelete(Swift3FunctionalTestCase):
self.conn.make_request('POST', bucket, body=xml,
headers={'Content-MD5': content_md5},
query=query)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
elem = fromstring(body, 'DeleteResult')
resp_objects = elem.findall('Deleted')
self.assertEquals(len(resp_objects), 1)
self.assertEqual(len(resp_objects), 1)
@unittest.skipIf(os.environ['AUTH'] == 'tempauth',

183
swift3/test/functional/test_multi_upload.py

@ -97,57 +97,57 @@ class TestSwift3MultiUpload(Swift3FunctionalTestCase):
# Initiate Multipart Upload
for expected_key, (status, headers, body) in \
izip(keys, results_generator):
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
self.assertTrue('content-type' in headers)
self.assertEquals(headers['content-type'], 'application/xml')
self.assertEqual(headers['content-type'], 'application/xml')
self.assertTrue('content-length' in headers)
self.assertEquals(headers['content-length'], str(len(body)))
self.assertEqual(headers['content-length'], str(len(body)))
elem = fromstring(body, 'InitiateMultipartUploadResult')
self.assertEquals(elem.find('Bucket').text, bucket)
self.assertEqual(elem.find('Bucket').text, bucket)
key = elem.find('Key').text
self.assertEquals(expected_key, key)
self.assertEqual(expected_key, key)
upload_id = elem.find('UploadId').text
self.assertTrue(upload_id is not None)
self.assertTrue((key, upload_id) not in uploads)
uploads.append((key, upload_id))
self.assertEquals(len(uploads), len(keys)) # sanity
self.assertEqual(len(uploads), len(keys)) # sanity
# List Multipart Uploads
query = 'uploads'
status, headers, body = \
self.conn.make_request('GET', bucket, query=query)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
self.assertTrue('content-type' in headers)
self.assertEquals(headers['content-type'], 'application/xml')
self.assertEqual(headers['content-type'], 'application/xml')
self.assertTrue('content-length' in headers)
self.assertEquals(headers['content-length'], str(len(body)))
self.assertEqual(headers['content-length'], str(len(body)))
elem = fromstring(body, 'ListMultipartUploadsResult')
self.assertEquals(elem.find('Bucket').text, bucket)
self.assertEquals(elem.find('KeyMarker').text, None)
self.assertEquals(elem.find('NextKeyMarker').text, uploads[-1][0])
self.assertEquals(elem.find('UploadIdMarker').text, None)
self.assertEquals(elem.find('NextUploadIdMarker').text, uploads[-1][1])
self.assertEquals(elem.find('MaxUploads').text, '1000')
self.assertEqual(elem.find('Bucket').text, bucket)
self.assertEqual(elem.find('KeyMarker').text, None)
self.assertEqual(elem.find('NextKeyMarker').text, uploads[-1][0])
self.assertEqual(elem.find('UploadIdMarker').text, None)
self.assertEqual(elem.find('NextUploadIdMarker').text, uploads[-1][1])
self.assertEqual(elem.find('MaxUploads').text, '1000')
self.assertTrue(elem.find('EncodingType') is None)
self.assertEquals(elem.find('IsTruncated').text, 'false')
self.assertEquals(len(elem.findall('Upload')), 2)
self.assertEqual(elem.find('IsTruncated').text, 'false')
self.assertEqual(len(elem.findall('Upload')), 2)
for (expected_key, expected_upload_id), u in \
izip(uploads, elem.findall('Upload')):
key = u.find('Key').text
upload_id = u.find('UploadId').text
self.assertEquals(expected_key, key)
self.assertEquals(expected_upload_id, upload_id)
self.assertEquals(u.find('Initiator/ID').text,
self.conn.user_id)
self.assertEquals(u.find('Initiator/DisplayName').text,
self.conn.user_id)
self.assertEquals(u.find('Owner/ID').text, self.conn.user_id)
self.assertEquals(u.find('Owner/DisplayName').text,
self.conn.user_id)
self.assertEquals(u.find('StorageClass').text, 'STANDARD')
self.assertEqual(expected_key, key)
self.assertEqual(expected_upload_id, upload_id)
self.assertEqual(u.find('Initiator/ID').text,
self.conn.user_id)
self.assertEqual(u.find('Initiator/DisplayName').text,
self.conn.user_id)
self.assertEqual(u.find('Owner/ID').text, self.conn.user_id)
self.assertEqual(u.find('Owner/DisplayName').text,
self.conn.user_id)
self.assertEqual(u.find('StorageClass').text, 'STANDARD')
self.assertTrue(u.find('Initiated').text is not None)
# Upload Part
@ -156,12 +156,12 @@ class TestSwift3MultiUpload(Swift3FunctionalTestCase):
etag = md5(content).hexdigest()
status, headers, body = \
self._upload_part(bucket, key, upload_id, content)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers, etag)
self.assertTrue('content-type' in headers)
self.assertEquals(headers['content-type'], 'text/html; charset=UTF-8')
self.assertEqual(headers['content-type'], 'text/html; charset=UTF-8')
self.assertTrue('content-length' in headers)
self.assertEquals(headers['content-length'], '0')
self.assertEqual(headers['content-length'], '0')
expected_parts_list = [(headers['etag'], mktime(headers['date']))]
# Upload Part Copy
@ -180,19 +180,19 @@ class TestSwift3MultiUpload(Swift3FunctionalTestCase):
status, headers, body, resp_etag = \
self._upload_part_copy(src_bucket, src_obj, bucket,
key, upload_id)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
self.assertTrue('content-type' in headers)
self.assertEquals(headers['content-type'], 'application/xml')
self.assertEqual(headers['content-type'], 'application/xml')
self.assertTrue('content-length' in headers)
self.assertEquals(headers['content-length'], str(len(body)))
self.assertEqual(headers['content-length'], str(len(body)))
self.assertTrue('etag' not in headers)
elem = fromstring(body, 'CopyPartResult')
last_modified = elem.find('LastModified').text
self.assertTrue(last_modified is not None)
self.assertEquals(resp_etag, etag)
self.assertEqual(resp_etag, etag)
# Check last-modified timestamp
key, upload_id = uploads[1]
@ -205,7 +205,7 @@ class TestSwift3MultiUpload(Swift3FunctionalTestCase):
# FIXME: COPY result drops mili/microseconds but GET doesn't
last_modified_gets = [p.find('LastModified').text
for p in elem.iterfind('Part')]
self.assertEquals(
self.assertEqual(
last_modified_gets[0].rsplit('.', 1)[0],
last_modified.rsplit('.', 1)[0],
'%r != %r' % (last_modified_gets[0], last_modified))
@ -217,28 +217,29 @@ class TestSwift3MultiUpload(Swift3FunctionalTestCase):
query = 'uploadId=%s' % upload_id
status, headers, body = \
self.conn.make_request('GET', bucket, key, query=query)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
self.assertTrue('content-type' in headers)
self.assertEquals(headers['content-type'], 'application/xml')
self.assertEqual(headers['content-type'], 'application/xml')
self.assertTrue('content-length' in headers)
self.assertEquals(headers['content-length'], str(len(body)))
self.assertEqual(headers['content-length'], str(len(body)))
elem = fromstring(body, 'ListPartsResult')
self.assertEquals(elem.find('Bucket').text, bucket)
self.assertEquals(elem.find('Key').text, key)
self.assertEquals(elem.find('UploadId').text, upload_id)
self.assertEquals(elem.find('Initiator/ID').text, self.conn.user_id)
self.assertEquals(elem.find('Initiator/DisplayName').text,
self.conn.user_id)
self.assertEquals(elem.find('Owner/ID').text, self.conn.user_id)
self.assertEquals(elem.find('Owner/DisplayName').text,
self.conn.user_id)
self.assertEquals(elem.find('StorageClass').text, 'STANDARD')
self.assertEquals(elem.find('PartNumberMarker').text, '0')
self.assertEquals(elem.find('NextPartNumberMarker').text, '1')
self.assertEquals(elem.find('MaxParts').text, '1000')
self.assertEquals(elem.find('IsTruncated').text, 'false')
self.assertEquals(len(elem.findall('Part')), 1)
self.assertEqual(elem.find('Bucket').text, bucket)
self.assertEqual(elem.find('Key').text, key)
self.assertEqual(elem.find('UploadId').text, upload_id)
self.assertEqual(elem.find('Initiator/ID').text, self.conn.user_id)
self.assertEqual(elem.find('Initiator/DisplayName').text,
self.conn.user_id)
self.assertEqual(elem.find('Owner/ID').text, self.conn.user_id)
self.assertEqual(elem.find('Owner/DisplayName').text,
self.conn.user_id)
self.assertEqual(elem.find('StorageClass').text, 'STANDARD')
self.assertEqual(elem.find('PartNumberMarker').text, '0')
self.assertEqual(elem.find('NextPartNumberMarker').text, '1')
self.assertEqual(elem.find('MaxParts').text, '1000')
self.assertEqual(elem.find('IsTruncated').text, 'false')
self.assertEqual(len(elem.findall('Part')), 1)
# etags will be used to generate xml for Complete Multipart Upload
etags = []
for (expected_etag, expected_date), p in \
@ -251,10 +252,10 @@ class TestSwift3MultiUpload(Swift3FunctionalTestCase):
# by the constraint of the format.
# For now, we can do either the format check or round check
# last_modified_from_xml = mktime(last_modified)
# self.assertEquals(expected_date,
# self.assertEqual(expected_date,
# last_modified_from_xml)
self.assertEquals(expected_etag, p.find('ETag').text)
self.assertEquals(MIN_SEGMENT_SIZE, int(p.find('Size').text))
self.assertEqual(expected_etag, p.find('ETag').text)
self.assertEqual(MIN_SEGMENT_SIZE, int(p.find('Size').text))
etags.append(p.find('ETag').text)
# Abort Multipart Upload
@ -262,29 +263,29 @@ class TestSwift3MultiUpload(Swift3FunctionalTestCase):
query = 'uploadId=%s' % upload_id
status, headers, body = \
self.conn.make_request('DELETE', bucket, key, query=query)
self.assertEquals(status, 204)
self.assertEqual(status, 204)
self.assertCommonResponseHeaders(headers)
self.assertTrue('content-type' in headers)
self.assertEquals(headers['content-type'], 'text/html; charset=UTF-8')
self.assertEqual(headers['content-type'], 'text/html; charset=UTF-8')
self.assertTrue('content-length' in headers)
self.assertEquals(headers['content-length'], '0')
self.assertEqual(headers['content-length'], '0')
# Complete Multipart Upload
key, upload_id = uploads[0]
xml = self._gen_comp_xml(etags)
status, headers, body = \
self._complete_multi_upload(bucket, key, upload_id, xml)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
self.assertTrue('content-type' in headers)
self.assertEquals(headers['content-type'], 'application/xml')
self.assertEqual(headers['content-type'], 'application/xml')
self.assertTrue('content-length' in headers)
self.assertEquals(headers['content-length'], str(len(body)))
self.assertEqual(headers['content-length'], str(len(body)))
elem = fromstring(body, 'CompleteMultipartUploadResult')
self.assertEquals('http://localhost:8080/bucket/obj1',
elem.find('Location').text)
self.assertEquals(elem.find('Bucket').text, bucket)
self.assertEquals(elem.find('Key').text, key)
self.assertEqual('http://localhost:8080/bucket/obj1',
elem.find('Location').text)
self.assertEqual(elem.find('Bucket').text, bucket)
self.assertEqual(elem.find('Key').text, key)
# TODO: confirm completed etag value
self.assertTrue(elem.find('ETag').text is not None)
@ -297,11 +298,11 @@ class TestSwift3MultiUpload(Swift3FunctionalTestCase):
auth_error_conn = Connection(aws_secret_key='invalid')
status, headers, body = \
auth_error_conn.make_request('POST', bucket, key, query=query)
self.assertEquals(get_error_code(body), 'SignatureDoesNotMatch')
self.assertEqual(get_error_code(body), 'SignatureDoesNotMatch')
status, resp_headers, body = \
self.conn.make_request('POST', 'nothing', key, query=query)
self.assertEquals(get_error_code(body), 'NoSuchBucket')
self.assertEqual(get_error_code(body), 'NoSuchBucket')
def test_list_multi_uploads_error(self):
bucket = 'bucket'
@ -311,11 +312,11 @@ class TestSwift3MultiUpload(Swift3FunctionalTestCase):
auth_error_conn = Connection(aws_secret_key='invalid')
status, headers, body = \
auth_error_conn.make_request('GET', bucket, query=query)
self.assertEquals(get_error_code(body), 'SignatureDoesNotMatch')
self.assertEqual(get_error_code(body), 'SignatureDoesNotMatch')
status, headers, body = \
self.conn.make_request('GET', 'nothing', query=query)
self.assertEquals(get_error_code(body), 'NoSuchBucket')
self.assertEqual(get_error_code(body), 'NoSuchBucket')
def test_upload_part_error(self):
bucket = 'bucket'
@ -331,21 +332,21 @@ class TestSwift3MultiUpload(Swift3FunctionalTestCase):
auth_error_conn = Connection(aws_secret_key='invalid')
status, headers, body = \
auth_error_conn.make_request('PUT', bucket, key, query=query)
self.assertEquals(get_error_code(body), 'SignatureDoesNotMatch')
self.assertEqual(get_error_code(body), 'SignatureDoesNotMatch')
status, headers, body = \
self.conn.make_request('PUT', 'nothing', key, query=query)
self.assertEquals(get_error_code(body), 'NoSuchBucket')
self.assertEqual(get_error_code(body), 'NoSuchBucket')
query = 'partNumber=%s&uploadId=%s' % (1, 'nothing')
status, headers, body = \
self.conn.make_request('PUT', bucket, key, query=query)
self.assertEquals(get_error_code(body), 'NoSuchUpload')
self.assertEqual(get_error_code(body), 'NoSuchUpload')
query = 'partNumber=%s&uploadId=%s' % (0, upload_id)
status, headers, body = \
self.conn.make_request('PUT', bucket, key, query=query)
self.assertEquals(get_error_code(body), 'InvalidArgument')
self.assertEqual(get_error_code(body), 'InvalidArgument')
err_msg = 'Part number must be an integer between 1 and'
self.assertTrue(err_msg in get_error_msg(body))
@ -373,20 +374,20 @@ class TestSwift3MultiUpload(Swift3FunctionalTestCase):
'X-Amz-Copy-Source': src_path
},
query=query)
self.assertEquals(get_error_code(body), 'SignatureDoesNotMatch')
self.assertEqual(get_error_code(body), 'SignatureDoesNotMatch')
status, headers, body = \
self.conn.make_request('PUT', 'nothing', key,
headers={'X-Amz-Copy-Source': src_path},
query=query)
self.assertEquals(get_error_code(body), 'NoSuchBucket')
self.assertEqual(get_error_code(body), 'NoSuchBucket')
query = 'partNumber=%s&uploadId=%s' % (1, 'nothing')
status, headers, body = \
self.conn.make_request('PUT', bucket, key,
headers={'X-Amz-Copy-Source': src_path},
query=query)
self.assertEquals(get_error_code(body), 'NoSuchUpload')
self.assertEqual(get_error_code(body), 'NoSuchUpload')
src_path = '%s/%s' % (src_bucket, 'nothing')
query = 'partNumber=%s&uploadId=%s' % (1, upload_id)
@ -394,7 +395,7 @@ class TestSwift3MultiUpload(Swift3FunctionalTestCase):
self.conn.make_request('PUT', bucket, key,
headers={'X-Amz-Copy-Source': src_path},
query=query)
self.assertEquals(get_error_code(body), 'NoSuchKey')
self.assertEqual(get_error_code(body), 'NoSuchKey')
def test_list_parts_error(self):
bucket = 'bucket'
@ -411,16 +412,16 @@ class TestSwift3MultiUpload(Swift3FunctionalTestCase):
status, headers, body = \
auth_error_conn.make_request('GET', bucket, key, query=query)
self.assertEquals(get_error_code(body), 'SignatureDoesNotMatch')
self.assertEqual(get_error_code(body), 'SignatureDoesNotMatch')
status, headers, body = \
self.conn.make_request('GET', 'nothing', key, query=query)
self.assertEquals(get_error_code(body), 'NoSuchBucket')
self.assertEqual(get_error_code(body), 'NoSuchBucket')
query = 'uploadId=%s' % 'nothing'
status, headers, body = \
self.conn.make_request('GET', bucket, key, query=query)
self.assertEquals(get_error_code(body), 'NoSuchUpload')
self.assertEqual(get_error_code(body), 'NoSuchUpload')
def test_abort_multi_upload_error(self):
bucket = 'bucket'
@ -437,16 +438,16 @@ class TestSwift3MultiUpload(Swift3FunctionalTestCase):
auth_error_conn = Connection(aws_secret_key='invalid')
status, headers, body = \
auth_error_conn.make_request('DELETE', bucket, key, query=query)
self.assertEquals(get_error_code(body), 'SignatureDoesNotMatch')
self.assertEqual(get_error_code(body), 'SignatureDoesNotMatch')
status, headers, body = \
self.conn.make_request('DELETE', 'nothing', key, query=query)
self.assertEquals(get_error_code(body), 'NoSuchBucket')
self.assertEqual(get_error_code(body), 'NoSuchBucket')
query = 'uploadId=%s' % 'nothing'
status, headers, body = \
self.conn.make_request('DELETE', bucket, key, query=query)
self.assertEquals(get_error_code(body), 'NoSuchUpload')
self.assertEqual(get_error_code(body), 'NoSuchUpload')
def test_complete_multi_upload_error(self):
bucket = 'bucket'
@ -478,19 +479,19 @@ class TestSwift3MultiUpload(Swift3FunctionalTestCase):
status, headers, body = \
auth_error_conn.make_request('POST', bucket, keys[0], body=xml,
query=query)
self.assertEquals(get_error_code(body), 'SignatureDoesNotMatch')
self.assertEqual(get_error_code(body), 'SignatureDoesNotMatch')
# wrong/missing bucket
status, headers, body = \
self.conn.make_request('POST', 'nothing', keys[0], query=query)
self.assertEquals(get_error_code(body), 'NoSuchBucket')
self.assertEqual(get_error_code(body), 'NoSuchBucket')
# wrong upload ID
query = 'uploadId=%s' % 'nothing'
status, headers, body = \
self.conn.make_request('POST', bucket, keys[0], body=xml,
query=query)
self.assertEquals(get_error_code(body), 'NoSuchUpload')
self.assertEqual(get_error_code(body), 'NoSuchUpload')
# without Part tag in xml
query = 'uploadId=%s' % upload_id
@ -498,7 +499,7 @@ class TestSwift3MultiUpload(Swift3FunctionalTestCase):
status, headers, body = \
self.conn.make_request('POST', bucket, keys[0], body=xml,
query=query)
self.assertEquals(get_error_code(body), 'MalformedXML')
self.assertEqual(get_error_code(body), 'MalformedXML')
# with ivalid etag in xml
invalid_etag = 'invalid'
@ -506,7 +507,7 @@ class TestSwift3MultiUpload(Swift3FunctionalTestCase):
status, headers, body = \
self.conn.make_request('POST', bucket, keys[0], body=xml,
query=query)
self.assertEquals(get_error_code(body), 'InvalidPart')
self.assertEqual(get_error_code(body), 'InvalidPart')
# without part in Swift
query = 'uploads'
@ -519,7 +520,7 @@ class TestSwift3MultiUpload(Swift3FunctionalTestCase):
status, headers, body = \
self.conn.make_request('POST', bucket, keys[1], body=xml,
query=query)
self.assertEquals(get_error_code(body), 'InvalidPart')
self.assertEqual(get_error_code(body), 'InvalidPart')
def test_complete_upload_with_fewer_etags(self):
bucket = 'bucket'
@ -543,7 +544,7 @@ class TestSwift3MultiUpload(Swift3FunctionalTestCase):
status, headers, body = \
self.conn.make_request('POST', bucket, key, body=xml,
query=query)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
def test_object_multi_upload_part_copy_range(self):
bucket = 'bucket'

216
swift3/test/functional/test_object.py

@ -46,7 +46,7 @@ class TestSwift3Object(Swift3FunctionalTestCase):
def _assertObjectEtag(self, bucket, obj, etag):
status, headers, _ = self.conn.make_request('HEAD', bucket, obj)
self.assertEquals(status, 200) # sanity
self.assertEqual(status, 200) # sanity
self.assertCommonResponseHeaders(headers, etag)
def test_object(self):
@ -57,11 +57,11 @@ class TestSwift3Object(Swift3FunctionalTestCase):
# PUT Object
status, headers, body = \
self.conn.make_request('PUT', self.bucket, obj, body=content)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
self.assertTrue('content-length' in headers) # sanity
self.assertEquals(headers['content-length'], '0')
self.assertEqual(headers['content-length'], '0')
self._assertObjectEtag(self.bucket, obj, etag)
# PUT Object Copy
@ -72,7 +72,7 @@ class TestSwift3Object(Swift3FunctionalTestCase):
status, headers, body = \
self.conn.make_request('PUT', dst_bucket, dst_obj,
headers=headers)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
# PUT Object Copy with URL-encoded Source
dst_bucket = 'dst-bucket'
@ -82,66 +82,66 @@ class TestSwift3Object(Swift3FunctionalTestCase):
status, headers, body = \
self.conn.make_request('PUT', dst_bucket, dst_obj,
headers=headers)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
self.assertEquals(headers['content-length'], str(len(body)))
self.assertEqual(headers['content-length'], str(len(body)))
elem = fromstring(body, 'CopyObjectResult')
self.assertTrue(elem.find('LastModified').text is not None)
last_modified_xml = elem.find('LastModified').text
self.assertTrue(elem.find('ETag').text is not None)
self.assertEquals(etag, elem.find('ETag').text.strip('"'))
self.assertEqual(etag, elem.find('ETag').text.strip('"'))
self._assertObjectEtag(dst_bucket, dst_obj, etag)
# Check timestamp on Copy:
status, headers, body = \
self.conn.make_request('GET', dst_bucket)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
elem = fromstring(body, 'ListBucketResult')
# FIXME: COPY result drops mili/microseconds but GET doesn't
self.assertEquals(
self.assertEqual(
elem.find('Contents').find("LastModified").text.rsplit('.', 1)[0],
last_modified_xml.rsplit('.', 1)[0])
# GET Object
status, headers, body = \
self.conn.make_request('GET', self.bucket, obj)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers, etag)
self.assertTrue(headers['last-modified'] is not None)
self.assertTrue(headers['content-type'] is not None)
self.assertEquals(headers['content-length'], str(len(content)))
self.assertEqual(headers['content-length'], str(len(content)))
# HEAD Object
status, headers, body = \
self.conn.make_request('HEAD', self.bucket, obj)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers, etag)
self.assertTrue(headers['last-modified'] is not None)
self.assertTrue('content-type' in headers)
self.assertEquals(headers['content-length'], str(len(content)))
self.assertEqual(headers['content-length'], str(len(content)))
# DELETE Object
status, headers, body = \
self.conn.make_request('DELETE', self.bucket, obj)
self.assertEquals(status, 204)
self.assertEqual(status, 204)
self.assertCommonResponseHeaders(headers)
def test_put_object_error(self):
auth_error_conn = Connection(aws_secret_key='invalid')
status, headers, body = \
auth_error_conn.make_request('PUT', self.bucket, 'object')
self.assertEquals(get_error_code(body), 'SignatureDoesNotMatch')
self.assertEquals(headers['content-type'], 'application/xml')
self.assertEqual(get_error_code(body), 'SignatureDoesNotMatch')
self.assertEqual(headers['content-type'], 'application/xml')
status, headers, body = \
self.conn.make_request('PUT', 'bucket2', 'object')
self.assertEquals(get_error_code(body), 'NoSuchBucket')
self.assertEquals(headers['content-type'], 'application/xml')
self.assertEqual(get_error_code(body), 'NoSuchBucket')
self.assertEqual(headers['content-type'], 'application/xml')
def test_put_object_copy_error(self):
obj = 'object'
@ -154,29 +154,29 @@ class TestSwift3Object(Swift3FunctionalTestCase):
auth_error_conn = Connection(aws_secret_key='invalid')
status, headers, body = \
auth_error_conn.make_request('PUT', dst_bucket, dst_obj, headers)
self.assertEquals(get_error_code(body), 'SignatureDoesNotMatch')
self.assertEquals(headers['content-type'], 'application/xml')
self.assertEqual(get_error_code(body), 'SignatureDoesNotMatch')
self.assertEqual(headers['content-type'], 'application/xml')
# /src/nothing -> /dst/dst
headers = {'X-Amz-Copy-Source': '/%s/%s' % (self.bucket, 'nothing')}
status, headers, body = \
self.conn.make_request('PUT', dst_bucket, dst_obj, headers)
self.assertEquals(get_error_code(body), 'NoSuchKey')
self.assertEquals(headers['content-type'], 'application/xml')
self.assertEqual(get_error_code(body), 'NoSuchKey')
self.assertEqual(headers['content-type'], 'application/xml')
# /nothing/src -> /dst/dst
headers = {'X-Amz-Copy-Source': '/%s/%s' % ('nothing', obj)}
status, headers, body = \
self.conn.make_request('PUT', dst_bucket, dst_obj, headers)
# TODO: source bucket is not check.
# self.assertEquals(get_error_code(body), 'NoSuchBucket')
# self.assertEqual(get_error_code(body), 'NoSuchBucket')
# /src/src -> /nothing/dst
headers = {'X-Amz-Copy-Source': '/%s/%s' % (self.bucket, obj)}
status, headers, body = \
self.conn.make_request('PUT', 'nothing', dst_obj, headers)
self.assertEquals(get_error_code(body), 'NoSuchBucket')
self.assertEquals(headers['content-type'], 'application/xml')
self.assertEqual(get_error_code(body), 'NoSuchBucket')
self.assertEqual(headers['content-type'], 'application/xml')
def test_get_object_error(self):
obj = 'object'
@ -185,19 +185,19 @@ class TestSwift3Object(Swift3FunctionalTestCase):
auth_error_conn = Connection(aws_secret_key='invalid')
status, headers, body = \
auth_error_conn.make_request('GET', self.bucket, obj)
self.assertEquals(get_error_code(body), 'SignatureDoesNotMatch')
self.assertEquals(headers['content-type'], 'application/xml')
self.assertEqual(get_error_code(body), 'SignatureDoesNotMatch')
self.assertEqual(headers['content-type'], 'application/xml')
status, headers, body = \
self.conn.make_request('GET', self.bucket, 'invalid')
self.assertEquals(get_error_code(body), 'NoSuchKey')
self.assertEquals(headers['content-type'], 'application/xml')
self.assertEqual(get_error_code(body), 'NoSuchKey')
self.assertEqual(headers['content-type'], 'application/xml')
status, headers, body = self.conn.make_request('GET', 'invalid', obj)
# TODO; requires consideration
# self.assertEquals(get_error_code(body), 'NoSuchBucket')
self.assertEquals(get_error_code(body), 'NoSuchKey')
self.assertEquals(headers['content-type'], 'application/xml')
# self.assertEqual(get_error_code(body), 'NoSuchBucket')
self.assertEqual(get_error_code(body), 'NoSuchKey')
self.assertEqual(headers['content-type'], 'application/xml')
def test_head_object_error(self):
obj = 'object'
@ -206,21 +206,21 @@ class TestSwift3Object(Swift3FunctionalTestCase):
auth_error_conn = Connection(aws_secret_key='invalid')
status, headers, body = \
auth_error_conn.make_request('HEAD', self.bucket, obj)
self.assertEquals(status, 403)
self.assertEquals(body, '') # sanifty
self.assertEquals(headers['content-type'], 'application/xml')
self.assertEqual(status, 403)
self.assertEqual(body, '') # sanifty
self.assertEqual(headers['content-type'], 'application/xml')
status, headers, body = \
self.conn.make_request('HEAD', self.bucket, 'invalid')
self.assertEquals(status, 404)
self.assertEquals(body, '') # sanifty
self.assertEquals(headers['content-type'], 'application/xml')
self.assertEqual(status, 404)
self.assertEqual(body, '') # sanifty
self.assertEqual(headers['content-type'], 'application/xml')
status, headers, body = \
self.conn.make_request('HEAD', 'invalid', obj)
self.assertEquals(status, 404)
self.assertEquals(body, '') # sanifty
self.assertEquals(headers['content-type'], 'application/xml')
self.assertEqual(status, 404)
self.assertEqual(body, '') # sanifty
self.assertEqual(headers['content-type'], 'application/xml')
def test_delete_object_error(self):
obj = 'object'
@ -229,18 +229,18 @@ class TestSwift3Object(Swift3FunctionalTestCase):
auth_error_conn = Connection(aws_secret_key='invalid')
status, headers, body = \
auth_error_conn.make_request('DELETE', self.bucket, obj)
self.assertEquals(get_error_code(body), 'SignatureDoesNotMatch')
self.assertEquals(headers['content-type'], 'application/xml')
self.assertEqual(get_error_code(body), 'SignatureDoesNotMatch')
self.assertEqual(headers['content-type'], 'application/xml')
status, headers, body = \
self.conn.make_request('DELETE', self.bucket, 'invalid')
self.assertEquals(get_error_code(body), 'NoSuchKey')
self.assertEquals(headers['content-type'], 'application/xml')
self.assertEqual(get_error_code(body), 'NoSuchKey')
self.assertEqual(headers['content-type'], 'application/xml')
status, headers, body = \
self.conn.make_request('DELETE', 'invalid', obj)
self.assertEquals(get_error_code(body), 'NoSuchBucket')
self.assertEquals(headers['content-type'], 'application/xml')
self.assertEqual(get_error_code(body), 'NoSuchBucket')
self.assertEqual(headers['content-type'], 'application/xml')
def test_put_object_content_encoding(self):
obj = 'object'
@ -248,11 +248,11 @@ class TestSwift3Object(Swift3FunctionalTestCase):
headers = {'Content-Encoding': 'gzip'}
status, headers, body = \
self.conn.make_request('PUT', self.bucket, obj, headers)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
status, headers, body = \
self.conn.make_request('HEAD', self.bucket, obj)
self.assertTrue('content-encoding' in headers) # sanity
self.assertEquals(headers['content-encoding'], 'gzip')
self.assertEqual(headers['content-encoding'], 'gzip')
self.assertCommonResponseHeaders(headers)
self._assertObjectEtag(self.bucket, obj, etag)
@ -263,7 +263,7 @@ class TestSwift3Object(Swift3FunctionalTestCase):
headers = {'Content-MD5': calculate_md5(content)}
status, headers, body = \
self.conn.make_request('PUT', self.bucket, obj, headers, content)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
self._assertObjectEtag(self.bucket, obj, etag)
@ -274,10 +274,10 @@ class TestSwift3Object(Swift3FunctionalTestCase):
headers = {'Content-Type': 'text/plain'}
status, headers, body = \
self.conn.make_request('PUT', self.bucket, obj, headers, content)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
status, headers, body = \
self.conn.make_request('HEAD', self.bucket, obj)
self.assertEquals(headers['content-type'], 'text/plain')
self.assertEqual(headers['content-type'], 'text/plain')
self.assertCommonResponseHeaders(headers)
self._assertObjectEtag(self.bucket, obj, etag)
@ -287,27 +287,27 @@ class TestSwift3Object(Swift3FunctionalTestCase):
headers = {'If-None-Match': '*'}
status, headers, body = \
self.conn.make_request('PUT', self.bucket, obj, headers, content)
self.assertEquals(status, 501)
self.assertEqual(status, 501)
headers = {'If-Match': '*'}
status, headers, body = \
self.conn.make_request('PUT', self.bucket, obj, headers, content)
self.assertEquals(status, 501)
self.assertEqual(status, 501)
headers = {'If-Modified-Since': 'Sat, 27 Jun 2015 00:00:00 GMT'}
status, headers, body = \
self.conn.make_request('PUT', self.bucket, obj, headers, content)
self.assertEquals(status, 501)
self.assertEqual(status, 501)
headers = {'If-Unmodified-Since': 'Sat, 27 Jun 2015 00:00:00 GMT'}
status, headers, body = \
self.conn.make_request('PUT', self.bucket, obj, headers, content)
self.assertEquals(status, 501)
self.assertEqual(status, 501)
# None of the above should actually have created an object
status, headers, body = \
self.conn.make_request('HEAD', self.bucket, obj, {}, '')
self.assertEquals(status, 404)
self.assertEqual(status, 404)
def test_put_object_expect(self):
obj = 'object'
@ -316,7 +316,7 @@ class TestSwift3Object(Swift3FunctionalTestCase):
headers = {'Expect': '100-continue'}
status, headers, body = \
self.conn.make_request('PUT', self.bucket, obj, headers, content)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
self._assertObjectEtag(self.bucket, obj, etag)
@ -327,12 +327,12 @@ class TestSwift3Object(Swift3FunctionalTestCase):
status, headers, body = \
self.conn.make_request('PUT', self.bucket, obj,
req_headers, content)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
status, headers, body = \
self.conn.make_request('HEAD', self.bucket, obj)
for header, value in req_headers.items():
self.assertIn(header.lower(), headers)
self.assertEquals(headers[header.lower()], value)
self.assertEqual(headers[header.lower()], value)
self.assertCommonResponseHeaders(headers)
self._assertObjectEtag(self.bucket, obj, etag)
@ -368,7 +368,7 @@ class TestSwift3Object(Swift3FunctionalTestCase):
headers = {'X-Amz-Storage-Class': 'STANDARD'}
status, headers, body = \
self.conn.make_request('PUT', self.bucket, obj, headers, content)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
self._assertObjectEtag(self.bucket, obj, etag)
@ -386,7 +386,7 @@ class TestSwift3Object(Swift3FunctionalTestCase):
headers = {'X-Amz-Copy-Source': '/%s/%s' % (self.bucket, obj)}
status, headers, body = \
self.conn.make_request('PUT', dst_bucket, dst_obj, headers)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
self._assertObjectEtag(dst_bucket, dst_obj, etag)
@ -394,7 +394,7 @@ class TestSwift3Object(Swift3FunctionalTestCase):
headers = {'X-Amz-Copy-Source': '/%s/%s' % (self.bucket, obj)}
status, headers, body = \
self.conn.make_request('PUT', self.bucket, dst_obj, headers)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
self._assertObjectEtag(self.bucket, dst_obj, etag)
@ -405,7 +405,7 @@ class TestSwift3Object(Swift3FunctionalTestCase):
'X-Amz-Metadata-Directive': 'REPLACE'}
status, headers, body = \
self.conn.make_request('PUT', self.bucket, obj, headers)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self._assertObjectEtag(self.bucket, obj, etag)
self.assertCommonResponseHeaders(headers)
@ -422,11 +422,11 @@ class TestSwift3Object(Swift3FunctionalTestCase):
'X-Amz-Meta-Test': 'dst'}
status, headers, body = \
self.conn.make_request('PUT', dst_bucket, dst_obj, headers)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
status, headers, body = \
self.conn.make_request('HEAD', dst_bucket, dst_obj)
self.assertEquals(headers['x-amz-meta-test'], 'dst')
self.assertEqual(headers['x-amz-meta-test'], 'dst')
def test_put_object_copy_source_if_modified_since(self):
obj = 'object'
@ -444,7 +444,7 @@ class TestSwift3Object(Swift3FunctionalTestCase):
formatdate(src_datetime)}
status, headers, body = \
self.conn.make_request('PUT', dst_bucket, dst_obj, headers=headers)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
self._assertObjectEtag(self.bucket, obj, etag)
@ -464,7 +464,7 @@ class TestSwift3Object(Swift3FunctionalTestCase):
formatdate(src_datetime)}
status, headers, body = \
self.conn.make_request('PUT', dst_bucket, dst_obj, headers=headers)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
self._assertObjectEtag(self.bucket, obj, etag)
@ -483,7 +483,7 @@ class TestSwift3Object(Swift3FunctionalTestCase):
'X-Amz-Copy-Source-If-Match': etag}
status, headers, body = \
self.conn.make_request('PUT', dst_bucket, dst_obj, headers=headers)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
self._assertObjectEtag(self.bucket, obj, etag)
@ -499,7 +499,7 @@ class TestSwift3Object(Swift3FunctionalTestCase):
'X-Amz-Copy-Source-If-None-Match': 'none-match'}
status, headers, body = \
self.conn.make_request('PUT', dst_bucket, dst_obj, headers=headers)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
self._assertObjectEtag(self.bucket, obj, etag)
@ -510,9 +510,9 @@ class TestSwift3Object(Swift3FunctionalTestCase):
query = 'response-content-type=text/plain'
status, headers, body = \
self.conn.make_request('GET', self.bucket, obj, query=query)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
self.assertEquals(headers['content-type'], 'text/plain')
self.assertEqual(headers['content-type'], 'text/plain')
def test_get_object_response_content_language(self):
obj = 'object'
@ -521,9 +521,9 @@ class TestSwift3Object(Swift3FunctionalTestCase):
query = 'response-content-language=en'
status, headers, body = \
self.conn.make_request('GET', self.bucket, obj, query=query)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
self.assertEquals(headers['content-language'], 'en')
self.assertEqual(headers['content-language'], 'en')
def test_get_object_response_cache_control(self):
obj = 'object'
@ -532,9 +532,9 @@ class TestSwift3Object(Swift3FunctionalTestCase):
query = 'response-cache-control=private'
status, headers, body = \
self.conn.make_request('GET', self.bucket, obj, query=query)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
self.assertEquals(headers['cache-control'], 'private')
self.assertEqual(headers['cache-control'], 'private')
def test_get_object_response_content_disposition(self):
obj = 'object'
@ -543,9 +543,9 @@ class TestSwift3Object(Swift3FunctionalTestCase):
query = 'response-content-disposition=inline'
status, headers, body = \
self.conn.make_request('GET', self.bucket, obj, query=query)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
self.assertEquals(headers['content-disposition'], 'inline')
self.assertEqual(headers['content-disposition'], 'inline')
def test_get_object_response_content_encoding(self):
obj = 'object'
@ -554,9 +554,9 @@ class TestSwift3Object(Swift3FunctionalTestCase):
query = 'response-content-encoding=gzip'
status, headers, body = \
self.conn.make_request('GET', self.bucket, obj, query=query)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
self.assertEquals(headers['content-encoding'], 'gzip')
self.assertEqual(headers['content-encoding'], 'gzip')
def test_get_object_range(self):
obj = 'object'
@ -568,49 +568,49 @@ class TestSwift3Object(Swift3FunctionalTestCase):
headers = {'Range': 'bytes=1-5'}
status, headers, body = \
self.conn.make_request('GET', self.bucket, obj, headers=headers)
self.assertEquals(status, 206)
self.assertEqual(status, 206)
self.assertCommonResponseHeaders(headers)
self.assertTrue('content-length' in headers)
self.assertEquals(headers['content-length'], '5')
self.assertEqual(headers['content-length'], '5')
self.assertTrue('x-amz-meta-test' in headers)
self.assertEquals('swift', headers['x-amz-meta-test'])
self.assertEquals(body, 'bcdef')
self.assertEqual('swift', headers['x-amz-meta-test'])
self.assertEqual(body, 'bcdef')
headers = {'Range': 'bytes=5-'}
status, headers, body = \
self.conn.make_request('GET', self.bucket, obj, headers=headers)
self.assertEquals(status, 206)
self.assertEqual(status, 206)
self.assertCommonResponseHeaders(headers)
self.assertTrue('content-length' in headers)
self.assertEquals(headers['content-length'], '5')
self.assertEqual(headers['content-length'], '5')
self.assertTrue('x-amz-meta-test' in headers)
self.assertEquals('swift', headers['x-amz-meta-test'])
self.assertEquals(body, 'fghij')
self.assertEqual('swift', headers['x-amz-meta-test'])
self.assertEqual(body, 'fghij')
headers = {'Range': 'bytes=-5'}
status, headers, body = \
self.conn.make_request('GET', self.bucket, obj, headers=headers)
self.assertEquals(status, 206)
self.assertEqual(status, 206)
self.assertCommonResponseHeaders(headers)
self.assertTrue('content-length' in headers)
self.assertEquals(headers['content-length'], '5')
self.assertEqual(headers['content-length'], '5')
self.assertTrue('x-amz-meta-test' in headers)
self.assertEquals('swift', headers['x-amz-meta-test'])
self.assertEquals(body, 'fghij')
self.assertEqual('swift', headers['x-amz-meta-test'])
self.assertEqual(body, 'fghij')
ranges = ['1-2', '4-5']
headers = {'Range': 'bytes=%s' % ','.join(ranges)}
status, headers, body = \
self.conn.make_request('GET', self.bucket, obj, headers=headers)
self.assertEquals(status, 206)
self.assertEqual(status, 206)
self.assertCommonResponseHeaders(headers)
self.assertTrue('content-length' in headers)
self.assertTrue('content-type' in headers) # sanity
content_type, boundary = headers['content-type'].split(';')
self.assertEquals('multipart/byteranges', content_type)
self.assertEqual('multipart/byteranges', content_type)
self.assertTrue(boundary.startswith('boundary=')) # sanity
boundary_str = boundary[len('boundary='):]
@ -620,8 +620,8 @@ class TestSwift3Object(Swift3FunctionalTestCase):
def check_line_header(line, expected_key, expected_value):
key, value = line.split(':', 1)
self.assertEquals(expected_key, key.strip())
self.assertEquals(expected_value, value.strip())
self.assertEqual(expected_key, key.strip())
self.assertEqual(expected_value, value.strip())
for range_value in ranges:
start, end = map(int, range_value.split('-'))
@ -642,7 +642,7 @@ class TestSwift3Object(Swift3FunctionalTestCase):
lines[1].strip(), 'Content-Range', expected_range)
# rest
rest = [line for line in lines[2:] if line.strip()]
self.assertEquals(1, len(rest)) # sanity
self.assertEqual(1, len(rest)) # sanity
self.assertTrue(content[start:end], rest[0])
# no next section
@ -658,7 +658,7 @@ class TestSwift3Object(Swift3FunctionalTestCase):
headers = {'If-Modified-Since': formatdate(src_datetime)}
status, headers, body = \
self.conn.make_request('GET', self.bucket, obj, headers=headers)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
def test_get_object_if_unmodified_since(self):
@ -672,7 +672,7 @@ class TestSwift3Object(Swift3FunctionalTestCase):
{'If-Unmodified-Since': formatdate(src_datetime)}
status, headers, body = \
self.conn.make_request('GET', self.bucket, obj, headers=headers)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
def test_get_object_if_match(self):
@ -686,7 +686,7 @@ class TestSwift3Object(Swift3FunctionalTestCase):
headers = {'If-Match': etag}
status, headers, body = \
self.conn.make_request('GET', self.bucket, obj, headers=headers)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
def test_get_object_if_none_match(self):
@ -696,7 +696,7 @@ class TestSwift3Object(Swift3FunctionalTestCase):
headers = {'If-None-Match': 'none-match'}
status, headers, body = \
self.conn.make_request('GET', self.bucket, obj, headers=headers)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
def test_head_object_range(self):
@ -707,19 +707,19 @@ class TestSwift3Object(Swift3FunctionalTestCase):
headers = {'Range': 'bytes=1-5'}
status, headers, body = \
self.conn.make_request('HEAD', self.bucket, obj, headers=headers)
self.assertEquals(headers['content-length'], '5')
self.assertEqual(headers['content-length'], '5')
self.assertCommonResponseHeaders(headers)
headers = {'Range': 'bytes=5-'}
status, headers, body = \
self.conn.make_request('HEAD', self.bucket, obj, headers=headers)
self.assertEquals(headers['content-length'], '5')
self.assertEqual(headers['content-length'], '5')
self.assertCommonResponseHeaders(headers)
headers = {'Range': 'bytes=-5'}
status, headers, body = \
self.conn.make_request('HEAD', self.bucket, obj, headers=headers)
self.assertEquals(headers['content-length'], '5')
self.assertEqual(headers['content-length'], '5')
self.assertCommonResponseHeaders(headers)
def test_head_object_if_modified_since(self):
@ -733,7 +733,7 @@ class TestSwift3Object(Swift3FunctionalTestCase):
headers = {'If-Modified-Since': formatdate(dt)}
status, headers, body = \
self.conn.make_request('HEAD', self.bucket, obj, headers=headers)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
def test_head_object_if_unmodified_since(self):
@ -747,7 +747,7 @@ class TestSwift3Object(Swift3FunctionalTestCase):
headers = {'If-Unmodified-Since': formatdate(dt)}
status, headers, body = \
self.conn.make_request('HEAD', self.bucket, obj, headers=headers)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
def test_head_object_if_match(self):
@ -761,7 +761,7 @@ class TestSwift3Object(Swift3FunctionalTestCase):
headers = {'If-Match': etag}
status, headers, body = \
self.conn.make_request('HEAD', self.bucket, obj, headers=headers)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
def test_head_object_if_none_match(self):
@ -771,7 +771,7 @@ class TestSwift3Object(Swift3FunctionalTestCase):
headers = {'If-None-Match': 'none-match'}
status, headers, body = \
self.conn.make_request('HEAD', self.bucket, obj, headers=headers)
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)

16
swift3/test/functional/test_service.py

@ -29,7 +29,7 @@ class TestSwift3Service(Swift3FunctionalTestCase):
def test_service(self):
# GET Service(without bucket)
status, headers, body = self.conn.make_request('GET')
self.assertEquals(status, 200)
self.assertEqual(status, 200)
self.assertCommonResponseHeaders(headers)
self.assertTrue(headers['content-type'] is not None)
@ -38,21 +38,21 @@ class TestSwift3Service(Swift3FunctionalTestCase):
elem = fromstring(body, 'ListAllMyBucketsResult')
buckets = elem.findall('./Buckets/Bucket')
self.assertEquals(list(buckets), [])
self.assertEqual(list(buckets), [])
owner = elem.find('Owner')
self.assertEquals(self.conn.user_id, owner.find('ID').text)
self.assertEquals(self.conn.user_id, owner.find('DisplayName').text)
self.assertEqual(self.conn.user_id, owner.find('ID').text)
self.assertEqual(self.conn.user_id, owner.find('DisplayName').text)
# GET Service(with Bucket)
req_buckets = ('bucket', 'bucket2')
for bucket in req_buckets:
self.conn.make_request('PUT', bucket)
status, headers, body = self.conn.make_request('GET')
self.assertEquals(status, 200)
self.assertEqual(status, 200)
elem = fromstring(body, 'ListAllMyBucketsResult')
resp_buckets = elem.findall('./Buckets/Bucket')
self.assertEquals(len(list(resp_buckets)), 2)
self.assertEqual(len(list(resp_buckets)), 2)
for b in resp_buckets:
self.assertTrue(b.find('Name').text in req_buckets)
self.assertTrue(b.find('CreationDate') is not None)
@ -60,8 +60,8 @@ class TestSwift3Service(Swift3FunctionalTestCase):
def test_service_error_signature_not_match(self):
auth_error_conn = Connection(aws_secret_key='invalid')
status, headers, body = auth_error_conn.make_request('GET')
self.assertEquals(get_error_code(body), 'SignatureDoesNotMatch')
self.assertEquals(headers['content-type'], 'application/xml')
self.assertEqual(get_error_code(body), 'SignatureDoesNotMatch')
self.assertEqual(headers['content-type'], 'application/xml')
def test_service_error_no_date_header(self):
# Without x-amz-date/Date header, that makes 403 forbidden

26
swift3/test/unit/test_acl.py

@ -37,9 +37,9 @@ class TestSwift3Acl(Swift3TestCase):
def _check_acl(self, owner, body):
elem = fromstring(body, 'AccessControlPolicy')
permission = elem.find('./AccessControlList/Grant/Permission').text
self.assertEquals(permission, 'FULL_CONTROL')
self.assertEqual(permission, 'FULL_CONTROL')
name = elem.find('./AccessControlList/Grant/Grantee/ID').text
self.assertEquals(name, owner)
self.assertEqual(name, owner)
def test_bucket_acl_GET(self):
req = Request.blank('/bucket?acl',
@ -68,7 +68,7 @@ class TestSwift3Acl(Swift3TestCase):
'Date': self.get_date_header()},
body=xml)
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
req = Request.blank('/bucket?acl',
environ={'REQUEST_METHOD': 'PUT',
@ -79,7 +79,7 @@ class TestSwift3Acl(Swift3TestCase):
self.assertIsNone(req.content_length)
self.assertIsNone(req.message_length())
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def test_bucket_canned_acl_PUT(self):
req = Request.blank('/bucket?acl',
@ -88,7 +88,7 @@ class TestSwift3Acl(Swift3TestCase):
'Date': self.get_date_header(),
'X-AMZ-ACL': 'public-read'})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
@s3acl(s3acl_only=True)
def test_bucket_canned_acl_PUT_with_s3acl(self):
@ -99,8 +99,8 @@ class TestSwift3Acl(Swift3TestCase):
'X-AMZ-ACL': 'public-read'})
with mock.patch('swift3.request.handle_acl_header') as mock_handler:
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEquals(mock_handler.call_count, 0)
self.assertEqual(status.split()[0], '200')
self.assertEqual(mock_handler.call_count, 0)
def test_bucket_fails_with_both_acl_header_and_xml_PUT(self):
elem = Element('AccessControlPolicy')
@ -122,8 +122,8 @@ class TestSwift3Acl(Swift3TestCase):
'X-AMZ-ACL': 'public-read'},
body=xml)
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body),
'UnexpectedContent')
self.assertEqual(self._get_error_code(body),
'UnexpectedContent')
def test_object_acl_GET(self):
req = Request.blank('/bucket/object?acl',
@ -140,7 +140,7 @@ class TestSwift3Acl(Swift3TestCase):
'Date': self.get_date_header()},
body='invalid')
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'MalformedACLError')
self.assertEqual(self._get_error_code(body), 'MalformedACLError')
def test_handle_acl_header(self):
def check_generated_acl_header(acl, targets):
@ -149,7 +149,7 @@ class TestSwift3Acl(Swift3TestCase):
handle_acl_header(req)
for target in targets:
self.assertTrue(target[0] in req.headers)
self.assertEquals(req.headers[target[0]], target[1])
self.assertEqual(req.headers[target[0]], target[1])
check_generated_acl_header('public-read',
[('X-Container-Read', '.r:*,.rlistings')])
@ -182,9 +182,9 @@ class TestSwift3Acl(Swift3TestCase):
with self.assertRaises(InvalidArgument) as cm:
handle_acl_header(req)
self.assertTrue('argument_name' in cm.exception.info)
self.assertEquals(cm.exception.info['argument_name'], 'x-amz-acl')
self.assertEqual(cm.exception.info['argument_name'], 'x-amz-acl')
self.assertTrue('argument_value' in cm.exception.info)
self.assertEquals(cm.exception.info['argument_value'], 'invalid')
self.assertEqual(cm.exception.info['argument_value'], 'invalid')
if __name__ == '__main__':

2
swift3/test/unit/test_acl_utils.py

@ -33,7 +33,7 @@ class TestSwift3AclUtils(Swift3TestCase):
handle_acl_header(req)
for target in targets:
self.assertTrue(target[0] in req.headers)
self.assertEquals(req.headers[target[0]], target[1])
self.assertEqual(req.headers[target[0]], target[1])
check_generated_acl_header('public-read',
[('X-Container-Read', '.r:*,.rlistings')])

151
swift3/test/unit/test_bucket.py

@ -82,7 +82,7 @@ class TestSwift3Bucket(Swift3TestCase):
headers={'Authorization': 'AWS test:tester:hmac',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def test_bucket_HEAD_error(self):
req = Request.blank('/nojunk',
@ -90,8 +90,8 @@ class TestSwift3Bucket(Swift3TestCase):
headers={'Authorization': 'AWS test:tester:hmac',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '404')
self.assertEquals(body, '') # sanifty
self.assertEqual(status.split()[0], '404')
self.assertEqual(body, '') # sanifty
def test_bucket_HEAD_slash(self):
req = Request.blank('/junk/',
@ -99,7 +99,7 @@ class TestSwift3Bucket(Swift3TestCase):
headers={'Authorization': 'AWS test:tester:hmac',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def test_bucket_HEAD_slash_error(self):
req = Request.blank('/nojunk/',
@ -107,18 +107,18 @@ class TestSwift3Bucket(Swift3TestCase):
headers={'Authorization': 'AWS test:tester:hmac',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '404')
self.assertEqual(status.split()[0], '404')
@s3acl
def test_bucket_GET_error(self):
code = self._test_method_error('GET', '/bucket', swob.HTTPUnauthorized)
self.assertEquals(code, 'SignatureDoesNotMatch')
self.assertEqual(code, 'SignatureDoesNotMatch')
code = self._test_method_error('GET', '/bucket', swob.HTTPForbidden)
self.assertEquals(code, 'AccessDenied')
self.assertEqual(code, 'AccessDenied')
code = self._test_method_error('GET', '/bucket', swob.HTTPNotFound)
self.assertEquals(code, 'NoSuchBucket')
self.assertEqual(code, 'NoSuchBucket')
code = self._test_method_error('GET', '/bucket', swob.HTTPServerError)
self.assertEquals(code, 'InternalError')
self.assertEqual(code, 'InternalError')
def test_bucket_GET(self):
bucket_name = 'junk'
@ -127,11 +127,11 @@ class TestSwift3Bucket(Swift3TestCase):
headers={'Authorization': 'AWS test:tester:hmac',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
elem = fromstring(body, 'ListBucketResult')
name = elem.find('./Name').text
self.assertEquals(name, bucket_name)
self.assertEqual(name, bucket_name)
objects = elem.iterchildren('Contents')
@ -142,7 +142,7 @@ class TestSwift3Bucket(Swift3TestCase):
o.find('./LastModified').text)
self.assertEqual('"0"', o.find('./ETag').text)
self.assertEquals(len(names), len(self.objects))
self.assertEqual(len(names), len(self.objects))
for i in self.objects:
self.assertTrue(i[0] in names)
@ -153,14 +153,14 @@ class TestSwift3Bucket(Swift3TestCase):
headers={'Authorization': 'AWS test:tester:hmac',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
elem = fromstring(body, 'ListBucketResult')
name = elem.find('./Name').text
self.assertEquals(name, bucket_name)
self.assertEqual(name, bucket_name)
prefixes = elem.findall('CommonPrefixes')
self.assertEquals(len(prefixes), len(self.prefixes))
self.assertEqual(len(prefixes), len(self.prefixes))
for p in prefixes:
self.assertTrue(p.find('./Prefix').text in self.prefixes)
@ -173,7 +173,7 @@ class TestSwift3Bucket(Swift3TestCase):
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
elem = fromstring(body, 'ListBucketResult')
self.assertEquals(elem.find('./IsTruncated').text, 'false')
self.assertEqual(elem.find('./IsTruncated').text, 'false')
req = Request.blank('/%s?max-keys=4' % bucket_name,
environ={'REQUEST_METHOD': 'GET'},
@ -181,7 +181,7 @@ class TestSwift3Bucket(Swift3TestCase):
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
elem = fromstring(body, 'ListBucketResult')
self.assertEquals(elem.find('./IsTruncated').text, 'true')
self.assertEqual(elem.find('./IsTruncated').text, 'true')
def test_bucket_GET_max_keys(self):
bucket_name = 'junk'
@ -192,7 +192,7 @@ class TestSwift3Bucket(Swift3TestCase):
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
elem = fromstring(body, 'ListBucketResult')
self.assertEquals(elem.find('./MaxKeys').text, '5')
self.assertEqual(elem.find('./MaxKeys').text, '5')
_, path = self.swift.calls[-1]
_, query_string = path.split('?')
args = dict(cgi.parse_qsl(query_string))
@ -204,11 +204,11 @@ class TestSwift3Bucket(Swift3TestCase):
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
elem = fromstring(body, 'ListBucketResult')
self.assertEquals(elem.find('./MaxKeys').text, '5000')
self.assertEqual(elem.find('./MaxKeys').text, '5000')
_, path = self.swift.calls[-1]
_, query_string = path.split('?')
args = dict(cgi.parse_qsl(query_string))
self.assertEquals(args['limit'], '1001')
self.assertEqual(args['limit'], '1001')
def test_bucket_GET_str_max_keys(self):
bucket_name = 'junk'
@ -218,7 +218,7 @@ class TestSwift3Bucket(Swift3TestCase):
headers={'Authorization': 'AWS test:tester:hmac',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'InvalidArgument')
self.assertEqual(self._get_error_code(body), 'InvalidArgument')
def test_bucket_GET_negative_max_keys(self):
bucket_name = 'junk'
@ -228,7 +228,7 @@ class TestSwift3Bucket(Swift3TestCase):
headers={'Authorization': 'AWS test:tester:hmac',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'InvalidArgument')
self.assertEqual(self._get_error_code(body), 'InvalidArgument')
def test_bucket_GET_over_32bit_int_max_keys(self):
bucket_name = 'junk'
@ -239,7 +239,7 @@ class TestSwift3Bucket(Swift3TestCase):
headers={'Authorization': 'AWS test:tester:hmac',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'InvalidArgument')
self.assertEqual(self._get_error_code(body), 'InvalidArgument')
def test_bucket_GET_passthroughs(self):
bucket_name = 'junk'
@ -249,15 +249,15 @@ class TestSwift3Bucket(Swift3TestCase):
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
elem = fromstring(body, 'ListBucketResult')
self.assertEquals(elem.find('./Prefix').text, 'c')
self.assertEquals(elem.find('./Marker').text, 'b')
self.assertEquals(elem.find('./Delimiter').text, 'a')
self.assertEqual(elem.find('./Prefix').text, 'c')
self.assertEqual(elem.find('./Marker').text, 'b')
self.assertEqual(elem.find('./Delimiter').text, 'a')
_, path = self.swift.calls[-1]
_, query_string = path.split('?')
args = dict(cgi.parse_qsl(query_string))
self.assertEquals(args['delimiter'], 'a')
self.assertEquals(args['marker'], 'b')
self.assertEquals(args['prefix'], 'c')
self.assertEqual(args['delimiter'], 'a')
self.assertEqual(args['marker'], 'b')
self.assertEqual(args['prefix'], 'c')
def test_bucket_GET_with_nonascii_queries(self):
bucket_name = 'junk'
@ -269,15 +269,15 @@ class TestSwift3Bucket(Swift3TestCase):
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
elem = fromstring(body, 'ListBucketResult')
self.assertEquals(elem.find('./Prefix').text, '\xef\xbc\xa3')
self.assertEquals(elem.find('./Marker').text, '\xef\xbc\xa2')
self.assertEquals(elem.find('./Delimiter').text, '\xef\xbc\xa1')
self.assertEqual(elem.find('./Prefix').text, '\xef\xbc\xa3')
self.assertEqual(elem.find('./Marker').text, '\xef\xbc\xa2')
self.assertEqual(elem.find('./Delimiter').text, '\xef\xbc\xa1')
_, path = self.swift.calls[-1]
_, query_string = path.split('?')
args = dict(cgi.parse_qsl(query_string))
self.assertEquals(args['delimiter'], '\xef\xbc\xa1')
self.assertEquals(args['marker'], '\xef\xbc\xa2')
self.assertEquals(args['prefix'], '\xef\xbc\xa3')
self.assertEqual(args['delimiter'], '\xef\xbc\xa1')
self.assertEqual(args['marker'], '\xef\xbc\xa2')
self.assertEqual(args['prefix'], '\xef\xbc\xa3')
def test_bucket_GET_with_delimiter_max_keys(self):
bucket_name = 'junk'
@ -286,11 +286,11 @@ class TestSwift3Bucket(Swift3TestCase):
headers={'Authorization': 'AWS test:tester:hmac',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
elem = fromstring(body, 'ListBucketResult')
self.assertEquals(elem.find('./NextMarker').text, 'viola')
self.assertEquals(elem.find('./MaxKeys').text, '2')
self.assertEquals(elem.find('./IsTruncated').text, 'true')
self.assertEqual(elem.find('./NextMarker').text, 'viola')
self.assertEqual(elem.find('./MaxKeys').text, '2')
self.assertEqual(elem.find('./IsTruncated').text, 'true')
def test_bucket_GET_subdir_with_delimiter_max_keys(self):
bucket_name = 'junk-subdir'
@ -299,11 +299,11 @@ class TestSwift3Bucket(Swift3TestCase):
headers={'Authorization': 'AWS test:tester:hmac',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
elem = fromstring(body, 'ListBucketResult')
self.assertEquals(elem.find('./NextMarker').text, 'rose')
self.assertEquals(elem.find('./MaxKeys').text, '1')
self.assertEquals(elem.find('./IsTruncated').text, 'true')
self.assertEqual(elem.find('./NextMarker').text, 'rose')
self.assertEqual(elem.find('./MaxKeys').text, '1')
self.assertEqual(elem.find('./IsTruncated').text, 'true')
@s3acl
def test_bucket_PUT_error(self):
@ -314,13 +314,13 @@ class TestSwift3Bucket(Swift3TestCase):
headers={'Content-Length': '-1'})
self.assertEqual(code, 'InvalidArgument')
code = self._test_method_error('PUT', '/bucket', swob.HTTPUnauthorized)
self.assertEquals(code, 'SignatureDoesNotMatch')
self.assertEqual(code, 'SignatureDoesNotMatch')
code = self._test_method_error('PUT', '/bucket', swob.HTTPForbidden)
self.assertEquals(code, 'AccessDenied')
self.assertEqual(code, 'AccessDenied')
code = self._test_method_error('PUT', '/bucket', swob.HTTPAccepted)
self.assertEquals(code, 'BucketAlreadyExists')
self.assertEqual(code, 'BucketAlreadyExists')
code = self._test_method_error('PUT', '/bucket', swob.HTTPServerError)
self.assertEquals(code, 'InternalError')
self.assertEqual(code, 'InternalError')
code = self._test_method_error(
'PUT', '/bucket+bucket', swob.HTTPCreated)
self.assertEqual(code, 'InvalidBucketName')
@ -349,8 +349,8 @@ class TestSwift3Bucket(Swift3TestCase):
headers={'Authorization': 'AWS test:tester:hmac',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEquals(headers['Location'], '/bucket')
self.assertEqual(status.split()[0], '200')
self.assertEqual(headers['Location'], '/bucket')
# Apparently some clients will include a chunked transfer-encoding
# even with no body
@ -360,8 +360,8 @@ class TestSwift3Bucket(Swift3TestCase):
'Date': self.get_date_header(),
'Transfer-Encoding': 'chunked'})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEquals(headers['Location'], '/bucket')
self.assertEqual(status.split()[0], '200')
self.assertEqual(headers['Location'], '/bucket')
@s3acl
def test_bucket_PUT_with_location(self):
@ -375,7 +375,7 @@ class TestSwift3Bucket(Swift3TestCase):
'Date': self.get_date_header()},
body=xml)
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def test_bucket_PUT_with_canned_acl(self):
req = Request.blank('/bucket',
@ -384,10 +384,10 @@ class TestSwift3Bucket(Swift3TestCase):
'Date': self.get_date_header(),
'X-Amz-Acl': 'public-read'})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
_, _, headers = self.swift.calls_with_headers[-1]
self.assertTrue('X-Container-Read' in headers)
self.assertEquals(headers.get('X-Container-Read'), '.r:*,.rlistings')
self.assertEqual(headers.get('X-Container-Read'), '.r:*,.rlistings')
self.assertTrue('X-Container-Sysmeta-Swift3-Acl' not in headers)
@s3acl(s3acl_only=True)
@ -401,12 +401,12 @@ class TestSwift3Bucket(Swift3TestCase):
'Date': self.get_date_header(),
'X-Amz-Acl': 'public-read'})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
_, _, headers = self.swift.calls_with_headers[-1]
self.assertTrue('X-Container-Read' not in headers)
self.assertTrue('X-Container-Sysmeta-Swift3-Acl' in headers)
self.assertEquals(headers.get('X-Container-Sysmeta-Swift3-Acl'),
acl['x-container-sysmeta-swift3-acl'])
self.assertEqual(headers.get('X-Container-Sysmeta-Swift3-Acl'),
acl['x-container-sysmeta-swift3-acl'])
@s3acl
def test_bucket_PUT_with_location_error(self):
@ -420,8 +420,8 @@ class TestSwift3Bucket(Swift3TestCase):
'Date': self.get_date_header()},
body=xml)
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body),
'InvalidLocationConstraint')
self.assertEqual(self._get_error_code(body),
'InvalidLocationConstraint')
@s3acl
def test_bucket_PUT_with_location_invalid_xml(self):
@ -431,7 +431,7 @@ class TestSwift3Bucket(Swift3TestCase):
'Date': self.get_date_header()},
body='invalid_xml')
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'MalformedXML')
self.assertEqual(self._get_error_code(body), 'MalformedXML')
def _test_method_error_delete(self, path, sw_resp):
self.swift.register('HEAD', '/v1/AUTH_test' + path, sw_resp, {}, None)
@ -440,19 +440,19 @@ class TestSwift3Bucket(Swift3TestCase):
@s3acl
def test_bucket_DELETE_error(self):
code = self._test_method_error_delete('/bucket', swob.HTTPUnauthorized)
self.assertEquals(code, 'SignatureDoesNotMatch')
self.assertEqual(code, 'SignatureDoesNotMatch')
code = self._test_method_error_delete('/bucket', swob.HTTPForbidden)
self.assertEquals(code, 'AccessDenied')
self.assertEqual(code, 'AccessDenied')
code = self._test_method_error_delete('/bucket', swob.HTTPNotFound)
self.assertEquals(code, 'NoSuchBucket')
self.assertEqual(code, 'NoSuchBucket')
code = self._test_method_error_delete('/bucket', swob.HTTPServerError)
self.assertEquals(code, 'InternalError')
self.assertEqual(code, 'InternalError')
# bucket not empty is now validated at swift3
self.swift.register('HEAD', '/v1/AUTH_test/bucket', swob.HTTPNoContent,
{'X-Container-Object-Count': '1'}, None)
code = self._test_method_error('DELETE', '/bucket', swob.HTTPConflict)
self.assertEquals(code, 'BucketNotEmpty')
self.assertEqual(code, 'BucketNotEmpty')
@s3acl
def test_bucket_DELETE(self):
@ -466,7 +466,7 @@ class TestSwift3Bucket(Swift3TestCase):
headers={'Authorization': 'AWS test:tester:hmac',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '204')
self.assertEqual(status.split()[0], '204')
@s3acl
def test_bucket_DELETE_error_while_segment_bucket_delete(self):
@ -501,25 +501,25 @@ class TestSwift3Bucket(Swift3TestCase):
def test_bucket_GET_without_permission(self):
status, headers, body = self._test_bucket_for_s3acl('GET',
'test:other')
self.assertEquals(self._get_error_code(body), 'AccessDenied')
self.assertEqual(self._get_error_code(body), 'AccessDenied')
@s3acl(s3acl_only=True)
def test_bucket_GET_with_read_permission(self):
status, headers, body = self._test_bucket_for_s3acl('GET',
'test:read')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
@s3acl(s3acl_only=True)
def test_bucket_GET_with_fullcontrol_permission(self):
status, headers, body = \
self._test_bucket_for_s3acl('GET', 'test:full_control')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
@s3acl(s3acl_only=True)
def test_bucket_GET_with_owner_permission(self):
status, headers, body = self._test_bucket_for_s3acl('GET',
'test:tester')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def _test_bucket_GET_canned_acl(self, bucket):
req = Request.blank('/%s' % bucket,
@ -533,18 +533,18 @@ class TestSwift3Bucket(Swift3TestCase):
def test_bucket_GET_authenticated_users(self):
status, headers, body = \
self._test_bucket_GET_canned_acl('authenticated')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
@s3acl(s3acl_only=True)
def test_bucket_GET_all_users(self):
status, headers, body = self._test_bucket_GET_canned_acl('public')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
@s3acl(s3acl_only=True)
def test_bucket_DELETE_without_permission(self):
status, headers, body = self._test_bucket_for_s3acl('DELETE',
'test:other')
self.assertEquals(self._get_error_code(body), 'AccessDenied')
self.assertEqual(self._get_error_code(body), 'AccessDenied')
# Don't delete anything in backend Swift
called = [method for method, _, _ in self.swift.calls_with_headers]
self.assertNotIn('DELETE', called)
@ -553,7 +553,7 @@ class TestSwift3Bucket(Swift3TestCase):
def test_bucket_DELETE_with_write_permission(self):
status, headers, body = self._test_bucket_for_s3acl('DELETE',
'test:write')
self.assertEquals(self._get_error_code(body), 'AccessDenied')
self.assertEqual(self._get_error_code(body), 'AccessDenied')
# Don't delete anything in backend Swift
called = [method for method, _, _ in self.swift.calls_with_headers]
self.assertNotIn('DELETE', called)
@ -562,10 +562,11 @@ class TestSwift3Bucket(Swift3TestCase):
def test_bucket_DELETE_with_fullcontrol_permission(self):
status, headers, body = \
self._test_bucket_for_s3acl('DELETE', 'test:full_control')
self.assertEquals(self._get_error_code(body), 'AccessDenied')
self.assertEqual(self._get_error_code(body), 'AccessDenied')
# Don't delete anything in backend Swift
called = [method for method, _, _ in self.swift.calls_with_headers]
self.assertNotIn('DELETE', called)
if __name__ == '__main__':
unittest.main()

6
swift3/test/unit/test_cfg.py

@ -36,9 +36,9 @@ class TestSwift3Cfg(unittest.TestCase):
}
)
self.assertEquals(conf['a'], 'str2')
self.assertEquals(conf['b'], 100)
self.assertEquals(conf['c'], False)
self.assertEqual(conf['a'], 'str2')
self.assertEqual(conf['b'], 100)
self.assertEqual(conf['c'], False)
if __name__ == '__main__':
unittest.main()

14
swift3/test/unit/test_etree.py

@ -27,30 +27,30 @@ class TestSwift3Etree(unittest.TestCase):
# No namespace is same as having the S3 namespace.
xml = test_xml('', '')
elem = etree.fromstring(xml)
self.assertEquals(elem.find('./B').text, 'C')
self.assertEqual(elem.find('./B').text, 'C')
# The S3 namespace is handled as no namespace.
xml = test_xml('xmlns="%s"' % etree.XMLNS_S3, '')
elem = etree.fromstring(xml)
self.assertEquals(elem.find('./B').text, 'C')
self.assertEqual(elem.find('./B').text, 'C')
xml = test_xml('xmlns:s3="%s"' % etree.XMLNS_S3, 's3:')
elem = etree.fromstring(xml)
self.assertEquals(elem.find('./B').text, 'C')
self.assertEqual(elem.find('./B').text, 'C')
# Any namespaces without a prefix work as no namespace.
xml = test_xml('xmlns="http://example.com/"', '')
elem = etree.fromstring(xml)
self.assertEquals(elem.find('./B').text, 'C')
self.assertEqual(elem.find('./B').text, 'C')
xml = test_xml('xmlns:s3="http://example.com/"', 's3:')
elem = etree.fromstring(xml)
self.assertEquals(elem.find('./B'), None)
self.assertEqual(elem.find('./B'), None)
def test_xml_with_comments(self):
xml = '<A><!-- comment --><B>C</B></A>'
elem = etree.fromstring(xml)
self.assertEquals(elem.find('./B').text, 'C')
self.assertEqual(elem.find('./B').text, 'C')
def test_tostring_with_nonascii_text(self):
elem = etree.Element('Test')
@ -65,7 +65,7 @@ class TestSwift3Etree(unittest.TestCase):
'<Test><FOO>\xef\xbc\xa1</FOO></Test>'
elem = etree.fromstring(input_str)
text = elem.find('FOO').text
self.assertEquals(text, '\xef\xbc\xa1')
self.assertEqual(text, '\xef\xbc\xa1')
self.assertTrue(isinstance(text, str))

2
swift3/test/unit/test_helpers.py

@ -29,7 +29,7 @@ class Swift3HelperTestCase(unittest.TestCase):
def _check_headers(self, swift, method, path, headers):
_, response_headers, _ = swift._responses[(method, path)]
self.assertEquals(headers, response_headers)
self.assertEqual(headers, response_headers)
def test_fake_swift_sysmeta(self):
swift = FakeSwift()

8
swift3/test/unit/test_location.py

@ -38,10 +38,10 @@ class TestSwift3Location(Swift3TestCase):
headers={'Authorization': 'AWS test:tester:hmac',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
elem = fromstring(body, 'LocationConstraint')
location = elem.text
self.assertEquals(location, None)
self.assertEqual(location, None)
def test_object_location_setting_as_us_west_1(self):
CONF.location = 'us-west-1'
@ -50,10 +50,10 @@ class TestSwift3Location(Swift3TestCase):
headers={'Authorization': 'AWS test:tester:hmac',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
elem = fromstring(body, 'LocationConstraint')
location = elem.text
self.assertEquals(location, 'us-west-1')
self.assertEqual(location, 'us-west-1')
if __name__ == '__main__':

12
swift3/test/unit/test_logging.py

@ -33,8 +33,8 @@ class TestSwift3Logging(Swift3TestCase):
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
xml = fromstring(body, 'BucketLoggingStatus')
self.assertEquals(xml.keys(), [])
self.assertEquals(status.split()[0], '200')
self.assertEqual(xml.keys(), [])
self.assertEqual(status.split()[0], '200')
def test_object_logging_GET_error(self):
req = Request.blank('/bucket/object?logging',
@ -42,7 +42,7 @@ class TestSwift3Logging(Swift3TestCase):
headers={'Authorization': 'AWS test:tester:hmac',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'NoLoggingStatusForKey')
self.assertEqual(self._get_error_code(body), 'NoLoggingStatusForKey')
def test_bucket_logging_PUT(self):
req = Request.blank('/bucket?logging',
@ -51,8 +51,8 @@ class TestSwift3Logging(Swift3TestCase):
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
# FIXME: Support PUT logging
# self.assertEquals(status, 201)
self.assertEquals(self._get_error_code(body), 'NotImplemented')
# self.assertEqual(status, 201)
self.assertEqual(self._get_error_code(body), 'NotImplemented')
def test_object_logging_PUT_error(self):
req = Request.blank('/bucket/object?logging',
@ -60,7 +60,7 @@ class TestSwift3Logging(Swift3TestCase):
headers={'Authorization': 'AWS test:tester:hmac',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'NoLoggingStatusForKey')
self.assertEqual(self._get_error_code(body), 'NoLoggingStatusForKey')
if __name__ == '__main__':
unittest.main()

58
swift3/test/unit/test_middleware.py

@ -42,14 +42,14 @@ class TestSwift3Middleware(Swift3TestCase):
def test_non_s3_request_passthrough(self):
req = Request.blank('/something')
status, headers, body = self.call_swift3(req)
self.assertEquals(body, 'FAKE APP')
self.assertEqual(body, 'FAKE APP')
def test_bad_format_authorization(self):
req = Request.blank('/something',
headers={'Authorization': 'hoge',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'AccessDenied')
self.assertEqual(self._get_error_code(body), 'AccessDenied')
def test_bad_method(self):
req = Request.blank('/',
@ -57,7 +57,7 @@ class TestSwift3Middleware(Swift3TestCase):
headers={'Authorization': 'AWS test:tester:hmac',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'MethodNotAllowed')
self.assertEqual(self._get_error_code(body), 'MethodNotAllowed')
def test_bad_method_but_method_exists_in_controller(self):
req = Request.blank(
@ -80,8 +80,8 @@ class TestSwift3Middleware(Swift3TestCase):
status, headers, body = self.call_swift3(req)
raw_path_info = "/%s/%s" % (bucket_name, object_name)
path_info = req.environ['PATH_INFO']
self.assertEquals(path_info, unquote(raw_path_info))
self.assertEquals(req.path, quote(path_info))
self.assertEqual(path_info, unquote(raw_path_info))
self.assertEqual(req.path, quote(path_info))
def test_canonical_string_v2(self):
"""
@ -106,7 +106,7 @@ class TestSwift3Middleware(Swift3TestCase):
def verify(hash, path, headers):
s = canonical_string(path, headers)
self.assertEquals(hash, hashlib.md5(s).hexdigest())
self.assertEqual(hash, hashlib.md5(s).hexdigest())
verify('6dd08c75e42190a1ce9468d1fd2eb787', '/bucket/object',
{'Content-Type': 'text/plain', 'X-Amz-Something': 'test',
@ -161,8 +161,8 @@ class TestSwift3Middleware(Swift3TestCase):
'X-Amz-Something': 'test'})
str3 = canonical_string('/', headers={'X-Amz-Something': 'test'})
self.assertEquals(str1, str2)
self.assertEquals(str2, str3)
self.assertEqual(str1, str2)
self.assertEqual(str2, str3)
def test_signed_urls_expired(self):
expire = '1000000000'
@ -173,7 +173,7 @@ class TestSwift3Middleware(Swift3TestCase):
req.headers['Date'] = datetime.utcnow()
req.content_type = 'text/plain'
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'AccessDenied')
self.assertEqual(self._get_error_code(body), 'AccessDenied')
def test_signed_urls(self):
# Set expire to last 32b timestamp value
@ -187,9 +187,9 @@ class TestSwift3Middleware(Swift3TestCase):
headers={'Date': self.get_date_header()})
req.content_type = 'text/plain'
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
for _, _, headers in self.swift.calls_with_headers:
self.assertEquals(headers['Authorization'], 'AWS test:tester:X')
self.assertEqual(headers['Authorization'], 'AWS test:tester:X')
def test_signed_urls_no_timestamp(self):
expire = '2147483647' # 19 Jan 2038 03:14:07
@ -200,9 +200,9 @@ class TestSwift3Middleware(Swift3TestCase):
status, headers, body = self.call_swift3(req)
# Curious! But actually S3 doesn't verify any x-amz-date/date headers
# for signed_url access and it also doesn't check timestamp
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
for _, _, headers in self.swift.calls_with_headers:
self.assertEquals(headers['Authorization'], 'AWS test:tester:X')
self.assertEqual(headers['Authorization'], 'AWS test:tester:X')
def test_signed_urls_invalid_expire(self):
expire = 'invalid'
@ -213,7 +213,7 @@ class TestSwift3Middleware(Swift3TestCase):
req.headers['Date'] = datetime.utcnow()
req.content_type = 'text/plain'
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'AccessDenied')
self.assertEqual(self._get_error_code(body), 'AccessDenied')
def test_signed_urls_no_sign(self):
expire = '2147483647' # 19 Jan 2038 03:14:07
@ -224,7 +224,7 @@ class TestSwift3Middleware(Swift3TestCase):
req.headers['Date'] = datetime.utcnow()
req.content_type = 'text/plain'
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'AccessDenied')
self.assertEqual(self._get_error_code(body), 'AccessDenied')
def test_signed_urls_no_access(self):
expire = '2147483647' # 19 Jan 2038 03:14:07
@ -330,7 +330,7 @@ class TestSwift3Middleware(Swift3TestCase):
'AWS test:tester:hmac'},
headers={'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def test_object_virtual_hosted_style(self):
req = Request.blank('/object',
@ -340,7 +340,7 @@ class TestSwift3Middleware(Swift3TestCase):
'AWS test:tester:hmac'},
headers={'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def test_token_generation(self):
self.swift.register('HEAD', '/v1/AUTH_test/bucket+segments/'
@ -357,7 +357,7 @@ class TestSwift3Middleware(Swift3TestCase):
req.headers['Date'] = date_header
status, headers, body = self.call_swift3(req)
_, _, headers = self.swift.calls_with_headers[-1]
self.assertEquals(base64.urlsafe_b64decode(
self.assertEqual(base64.urlsafe_b64decode(
headers['X-Auth-Token']),
'PUT\n\n\n%s\n/bucket/object?partNumber=1&uploadId=123456789abcdef'
% date_header)
@ -368,7 +368,7 @@ class TestSwift3Middleware(Swift3TestCase):
headers={'Authorization': 'AWS test:tester:hmac',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'InvalidURI')
self.assertEqual(self._get_error_code(body), 'InvalidURI')
def test_object_create_bad_md5_unreadable(self):
req = Request.blank('/bucket/object',
@ -377,7 +377,7 @@ class TestSwift3Middleware(Swift3TestCase):
'HTTP_CONTENT_MD5': '#'},
headers={'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'InvalidDigest')
self.assertEqual(self._get_error_code(body), 'InvalidDigest')
def test_object_create_bad_md5_too_short(self):
too_short_digest = md5('hey').hexdigest()[:-1]
@ -389,7 +389,7 @@ class TestSwift3Middleware(Swift3TestCase):
'HTTP_CONTENT_MD5': md5_str},
headers={'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'InvalidDigest')
self.assertEqual(self._get_error_code(body), 'InvalidDigest')
def test_object_create_bad_md5_too_long(self):
too_long_digest = md5('hey').hexdigest() + 'suffix'
@ -401,7 +401,7 @@ class TestSwift3Middleware(Swift3TestCase):
'HTTP_CONTENT_MD5': md5_str},
headers={'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'InvalidDigest')
self.assertEqual(self._get_error_code(body), 'InvalidDigest')
def test_invalid_metadata_directive(self):
req = Request.blank('/',
@ -411,7 +411,7 @@ class TestSwift3Middleware(Swift3TestCase):
'invalid'},
headers={'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'InvalidArgument')
self.assertEqual(self._get_error_code(body), 'InvalidArgument')
def test_invalid_storage_class(self):
req = Request.blank('/',
@ -420,7 +420,7 @@ class TestSwift3Middleware(Swift3TestCase):
'HTTP_X_AMZ_STORAGE_CLASS': 'INVALID'},
headers={'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'InvalidStorageClass')
self.assertEqual(self._get_error_code(body), 'InvalidStorageClass')
def _test_unsupported_header(self, header):
req = Request.blank('/error',
@ -429,7 +429,7 @@ class TestSwift3Middleware(Swift3TestCase):
headers={'x-amz-' + header: 'value',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'NotImplemented')
self.assertEqual(self._get_error_code(body), 'NotImplemented')
def test_mfa(self):
self._test_unsupported_header('mfa')
@ -446,7 +446,7 @@ class TestSwift3Middleware(Swift3TestCase):
'HTTP_AUTHORIZATION': 'AWS X:Y:Z'},
headers={'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'NotImplemented')
self.assertEqual(self._get_error_code(body), 'NotImplemented')
def test_notification(self):
self._test_unsupported_resource('notification')
@ -479,9 +479,9 @@ class TestSwift3Middleware(Swift3TestCase):
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
elem = fromstring(body, 'Error')
self.assertEquals(elem.find('./Code').text, 'MethodNotAllowed')
self.assertEquals(elem.find('./Method').text, 'POST')
self.assertEquals(elem.find('./ResourceType').text, 'ACL')
self.assertEqual(elem.find('./Code').text, 'MethodNotAllowed')
self.assertEqual(elem.find('./Method').text, 'POST')
self.assertEqual(elem.find('./ResourceType').text, 'ACL')
def test_registered_defaults(self):
filter_factory(CONF)

38
swift3/test/unit/test_multi_delete.py

@ -52,7 +52,7 @@ class TestSwift3MultiDelete(Swift3TestCase):
body=body)
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
@s3acl
def test_object_multi_DELETE(self):
@ -83,15 +83,15 @@ class TestSwift3MultiDelete(Swift3TestCase):
req.date = datetime.now()
req.content_type = 'text/plain'
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
elem = fromstring(body)
self.assertEquals(len(elem.findall('Deleted')), 3)
self.assertEqual(len(elem.findall('Deleted')), 3)
_, path, _ = self.swift.calls_with_headers[-1]
path, query_string = path.split('?', 1)
self.assertEquals(path, '/v1/AUTH_test/bucket/Key3')
self.assertEqual(path, '/v1/AUTH_test/bucket/Key3')
query = dict(urllib.parse.parse_qsl(query_string))
self.assertEquals(query['multipart-manifest'], 'delete')
self.assertEqual(query['multipart-manifest'], 'delete')
@s3acl
def test_object_multi_DELETE_quiet(self):
@ -115,10 +115,10 @@ class TestSwift3MultiDelete(Swift3TestCase):
'Content-MD5': content_md5},
body=body)
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
elem = fromstring(body)
self.assertEquals(len(elem.findall('Deleted')), 0)
self.assertEqual(len(elem.findall('Deleted')), 0)
@s3acl
def test_object_multi_DELETE_no_key(self):
@ -142,7 +142,7 @@ class TestSwift3MultiDelete(Swift3TestCase):
'Content-MD5': content_md5},
body=body)
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'UserKeyMustBeSpecified')
self.assertEqual(self._get_error_code(body), 'UserKeyMustBeSpecified')
@s3acl
def test_object_multi_DELETE_with_invalid_md5(self):
@ -159,7 +159,7 @@ class TestSwift3MultiDelete(Swift3TestCase):
'Content-MD5': 'XXXX'},
body=body)
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'InvalidDigest')
self.assertEqual(self._get_error_code(body), 'InvalidDigest')
@s3acl
def test_object_multi_DELETE_without_md5(self):
@ -175,7 +175,7 @@ class TestSwift3MultiDelete(Swift3TestCase):
'Date': self.get_date_header()},
body=body)
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'InvalidRequest')
self.assertEqual(self._get_error_code(body), 'InvalidRequest')
@s3acl
def test_object_multi_DELETE_too_many_keys(self):
@ -193,7 +193,7 @@ class TestSwift3MultiDelete(Swift3TestCase):
'Content-MD5': content_md5},
body=body)
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'MalformedXML')
self.assertEqual(self._get_error_code(body), 'MalformedXML')
def _test_object_multi_DELETE(self, account):
self.keys = ['Key1', 'Key2']
@ -225,29 +225,29 @@ class TestSwift3MultiDelete(Swift3TestCase):
@s3acl(s3acl_only=True)
def test_object_multi_DELETE_without_permission(self):
status, headers, body = self._test_object_multi_DELETE('test:other')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
elem = fromstring(body)
errors = elem.findall('Error')
self.assertEquals(len(errors), len(self.keys))
self.assertEqual(len(errors), len(self.keys))
for e in errors:
self.assertTrue(e.find('Key').text in self.keys)
self.assertEquals(e.find('Code').text, 'AccessDenied')
self.assertEquals(e.find('Message').text, 'Access Denied.')
self.assertEqual(e.find('Code').text, 'AccessDenied')
self.assertEqual(e.find('Message').text, 'Access Denied.')
@s3acl(s3acl_only=True)
def test_object_multi_DELETE_with_write_permission(self):
status, headers, body = self._test_object_multi_DELETE('test:write')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
elem = fromstring(body)
self.assertEquals(len(elem.findall('Deleted')), len(self.keys))
self.assertEqual(len(elem.findall('Deleted')), len(self.keys))
@s3acl(s3acl_only=True)
def test_object_multi_DELETE_with_fullcontrol_permission(self):
status, headers, body = \
self._test_object_multi_DELETE('test:full_control')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
elem = fromstring(body)
self.assertEquals(len(elem.findall('Deleted')), len(self.keys))
self.assertEqual(len(elem.findall('Deleted')), len(self.keys))
if __name__ == '__main__':
unittest.main()

460
swift3/test/unit/test_multi_upload.py

File diff suppressed because it is too large Load Diff

293
swift3/test/unit/test_obj.py

@ -88,7 +88,7 @@ class TestSwift3Obj(Swift3TestCase):
headers={'Authorization': 'AWS test:tester:hmac',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
unexpected_headers = []
for key, val in self.response_headers.iteritems():
@ -96,14 +96,14 @@ class TestSwift3Obj(Swift3TestCase):
'last-modified', 'cache-control', 'Content-Disposition',
'Content-Language', 'expires', 'x-robots-tag'):
self.assertIn(key, headers)
self.assertEquals(headers[key], str(val))
self.assertEqual(headers[key], str(val))
elif key == 'etag':
self.assertEquals(headers[key], '"%s"' % val)
self.assertEqual(headers[key], '"%s"' % val)
elif key.startswith('x-object-meta-'):
self.assertIn('x-amz-meta-' + key[14:], headers)
self.assertEquals(headers['x-amz-meta-' + key[14:]], val)
self.assertEqual(headers['x-amz-meta-' + key[14:]], val)
else:
unexpected_headers.append((key, val))
@ -111,11 +111,11 @@ class TestSwift3Obj(Swift3TestCase):
if unexpected_headers:
self.fail('unexpected headers: %r' % unexpected_headers)
self.assertEquals(headers['etag'],
'"%s"' % self.response_headers['etag'])
self.assertEqual(headers['etag'],
'"%s"' % self.response_headers['etag'])
if method == 'GET':
self.assertEquals(body, self.object_body)
self.assertEqual(body, self.object_body)
@s3acl
def test_object_HEAD_error(self):
@ -129,33 +129,33 @@ class TestSwift3Obj(Swift3TestCase):
self.swift.register('HEAD', '/v1/AUTH_test/bucket/object',
swob.HTTPUnauthorized, {}, None)
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '403')
self.assertEquals(body, '') # sanifty
self.assertEqual(status.split()[0], '403')
self.assertEqual(body, '') # sanifty
self.swift.register('HEAD', '/v1/AUTH_test/bucket/object',
swob.HTTPForbidden, {}, None)
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '403')
self.assertEquals(body, '') # sanifty
self.assertEqual(status.split()[0], '403')
self.assertEqual(body, '') # sanifty
self.swift.register('HEAD', '/v1/AUTH_test/bucket/object',
swob.HTTPNotFound, {}, None)
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '404')
self.assertEquals(body, '') # sanifty
self.assertEqual(status.split()[0], '404')
self.assertEqual(body, '') # sanifty
self.swift.register('HEAD', '/v1/AUTH_test/bucket/object',
swob.HTTPPreconditionFailed, {}, None)
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '412')
self.assertEquals(body, '') # sanifty
self.assertEqual(status.split()[0], '412')
self.assertEqual(body, '') # sanifty
self.swift.register('HEAD', '/v1/AUTH_test/bucket/object',
swob.HTTPServerError, {}, None)
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '500')
self.assertEquals(body, '') # sanifty
self.assertEqual(status.split()[0], '500')
self.assertEqual(body, '') # sanifty
self.swift.register('HEAD', '/v1/AUTH_test/bucket/object',
swob.HTTPServiceUnavailable, {}, None)
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '500')
self.assertEquals(body, '') # sanifty
self.assertEqual(status.split()[0], '500')
self.assertEqual(body, '') # sanifty
def test_object_HEAD(self):
self._test_object_GETorHEAD('HEAD')
@ -172,42 +172,42 @@ class TestSwift3Obj(Swift3TestCase):
def test_object_HEAD_Range_with_invalid_value(self):
range_value = ''
status, headers, body = self._test_object_HEAD_Range(range_value)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
self.assertTrue('content-length' in headers)
self.assertEqual(headers['content-length'], '5')
self.assertTrue('content-range' not in headers)
range_value = 'hoge'
status, headers, body = self._test_object_HEAD_Range(range_value)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
self.assertTrue('content-length' in headers)
self.assertEqual(headers['content-length'], '5')
self.assertTrue('content-range' not in headers)
range_value = 'bytes='
status, headers, body = self._test_object_HEAD_Range(range_value)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
self.assertTrue('content-length' in headers)
self.assertEqual(headers['content-length'], '5')
self.assertTrue('content-range' not in headers)
range_value = 'bytes=1'
status, headers, body = self._test_object_HEAD_Range(range_value)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
self.assertTrue('content-length' in headers)
self.assertEqual(headers['content-length'], '5')
self.assertTrue('content-range' not in headers)
range_value = 'bytes=5-1'
status, headers, body = self._test_object_HEAD_Range(range_value)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
self.assertTrue('content-length' in headers)
self.assertEqual(headers['content-length'], '5')
self.assertTrue('content-range' not in headers)
range_value = 'bytes=5-10'
status, headers, body = self._test_object_HEAD_Range(range_value)
self.assertEquals(status.split()[0], '416')
self.assertEqual(status.split()[0], '416')
@s3acl
def test_object_HEAD_Range(self):
@ -217,7 +217,7 @@ class TestSwift3Obj(Swift3TestCase):
self.object_body)
range_value = 'bytes=0-3'
status, headers, body = self._test_object_HEAD_Range(range_value)
self.assertEquals(status.split()[0], '206')
self.assertEqual(status.split()[0], '206')
self.assertTrue('content-length' in headers)
self.assertEqual(headers['content-length'], '4')
self.assertTrue('content-range' in headers)
@ -227,7 +227,7 @@ class TestSwift3Obj(Swift3TestCase):
range_value = 'bytes=3-3'
status, headers, body = self._test_object_HEAD_Range(range_value)
self.assertEquals(status.split()[0], '206')
self.assertEqual(status.split()[0], '206')
self.assertTrue('content-length' in headers)
self.assertEqual(headers['content-length'], '1')
self.assertTrue('content-range' in headers)
@ -237,7 +237,7 @@ class TestSwift3Obj(Swift3TestCase):
range_value = 'bytes=1-'
status, headers, body = self._test_object_HEAD_Range(range_value)
self.assertEquals(status.split()[0], '206')
self.assertEqual(status.split()[0], '206')
self.assertTrue('content-length' in headers)
self.assertEqual(headers['content-length'], '4')
self.assertTrue('content-range' in headers)
@ -247,7 +247,7 @@ class TestSwift3Obj(Swift3TestCase):
range_value = 'bytes=-3'
status, headers, body = self._test_object_HEAD_Range(range_value)
self.assertEquals(status.split()[0], '206')
self.assertEqual(status.split()[0], '206')
self.assertTrue('content-length' in headers)
self.assertEqual(headers['content-length'], '3')
self.assertTrue('content-range' in headers)
@ -259,22 +259,22 @@ class TestSwift3Obj(Swift3TestCase):
def test_object_GET_error(self):
code = self._test_method_error('GET', '/bucket/object',
swob.HTTPUnauthorized)
self.assertEquals(code, 'SignatureDoesNotMatch')
self.assertEqual(code, 'SignatureDoesNotMatch')
code = self._test_method_error('GET', '/bucket/object',
swob.HTTPForbidden)
self.assertEquals(code, 'AccessDenied')
self.assertEqual(code, 'AccessDenied')
code = self._test_method_error('GET', '/bucket/object',
swob.HTTPNotFound)
self.assertEquals(code, 'NoSuchKey')
self.assertEqual(code, 'NoSuchKey')
code = self._test_method_error('GET', '/bucket/object',
swob.HTTPServerError)
self.assertEquals(code, 'InternalError')
self.assertEqual(code, 'InternalError')
code = self._test_method_error('GET', '/bucket/object',
swob.HTTPPreconditionFailed)
self.assertEquals(code, 'PreconditionFailed')
self.assertEqual(code, 'PreconditionFailed')
code = self._test_method_error('GET', '/bucket/object',
swob.HTTPServiceUnavailable)
self.assertEquals(code, 'InternalError')
self.assertEqual(code, 'InternalError')
@s3acl
def test_object_GET(self):
@ -301,7 +301,7 @@ class TestSwift3Obj(Swift3TestCase):
'Range': 'bytes=0-3',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '206')
self.assertEqual(status.split()[0], '206')
self.assertTrue('content-range' in headers)
self.assertTrue(headers['content-range'].startswith('bytes 0-3'))
@ -310,7 +310,7 @@ class TestSwift3Obj(Swift3TestCase):
def test_object_GET_Range_error(self):
code = self._test_method_error('GET', '/bucket/object',
swob.HTTPRequestedRangeNotSatisfiable)
self.assertEquals(code, 'InvalidRange')
self.assertEqual(code, 'InvalidRange')
@s3acl
def test_object_GET_Response(self):
@ -331,76 +331,76 @@ class TestSwift3Obj(Swift3TestCase):
headers={'Authorization': 'AWS test:tester:hmac',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
self.assertTrue('content-type' in headers)
self.assertEquals(headers['content-type'], 'text/plain')
self.assertEqual(headers['content-type'], 'text/plain')
self.assertTrue('content-language' in headers)
self.assertEquals(headers['content-language'], 'en')
self.assertEqual(headers['content-language'], 'en')
self.assertTrue('expires' in headers)
self.assertEquals(headers['expires'], 'Fri, 01 Apr 2014 12:00:00 GMT')
self.assertEqual(headers['expires'], 'Fri, 01 Apr 2014 12:00:00 GMT')
self.assertTrue('cache-control' in headers)
self.assertEquals(headers['cache-control'], 'no-cache')
self.assertEqual(headers['cache-control'], 'no-cache')
self.assertTrue('content-disposition' in headers)
self.assertEquals(headers['content-disposition'],
'attachment')
self.assertEqual(headers['content-disposition'],
'attachment')
self.assertTrue('content-encoding' in headers)
self.assertEquals(headers['content-encoding'], 'gzip')
self.assertEqual(headers['content-encoding'], 'gzip')
@s3acl
def test_object_PUT_error(self):
code = self._test_method_error('PUT', '/bucket/object',
swob.HTTPUnauthorized)
self.assertEquals(code, 'SignatureDoesNotMatch')
self.assertEqual(code, 'SignatureDoesNotMatch')
code = self._test_method_error('PUT', '/bucket/object',
swob.HTTPForbidden)
self.assertEquals(code, 'AccessDenied')
self.assertEqual(code, 'AccessDenied')
code = self._test_method_error('PUT', '/bucket/object',
swob.HTTPNotFound)
self.assertEquals(code, 'NoSuchBucket')
self.assertEqual(code, 'NoSuchBucket')
code = self._test_method_error('PUT', '/bucket/object',
swob.HTTPRequestEntityTooLarge)
self.assertEquals(code, 'EntityTooLarge')
self.assertEqual(code, 'EntityTooLarge')
code = self._test_method_error('PUT', '/bucket/object',
swob.HTTPServerError)
self.assertEquals(code, 'InternalError')
self.assertEqual(code, 'InternalError')
code = self._test_method_error('PUT', '/bucket/object',
swob.HTTPUnprocessableEntity)
self.assertEquals(code, 'BadDigest')
self.assertEqual(code, 'BadDigest')
code = self._test_method_error('PUT', '/bucket/object',
swob.HTTPLengthRequired)
self.assertEquals(code, 'MissingContentLength')
self.assertEqual(code, 'MissingContentLength')
code = self._test_method_error('PUT', '/bucket/object',
swob.HTTPPreconditionFailed)
self.assertEquals(code, 'InternalError')
self.assertEqual(code, 'InternalError')
code = self._test_method_error('PUT', '/bucket/object',
swob.HTTPServiceUnavailable)
self.assertEquals(code, 'InternalError')
self.assertEqual(code, 'InternalError')
code = self._test_method_error('PUT', '/bucket/object',
swob.HTTPCreated,
{'X-Amz-Copy-Source': ''})
self.assertEquals(code, 'InvalidArgument')
self.assertEqual(code, 'InvalidArgument')
code = self._test_method_error('PUT', '/bucket/object',
swob.HTTPCreated,
{'X-Amz-Copy-Source': '/'})
self.assertEquals(code, 'InvalidArgument')
self.assertEqual(code, 'InvalidArgument')
code = self._test_method_error('PUT', '/bucket/object',
swob.HTTPCreated,
{'X-Amz-Copy-Source': '/bucket'})
self.assertEquals(code, 'InvalidArgument')
self.assertEqual(code, 'InvalidArgument')
code = self._test_method_error('PUT', '/bucket/object',
swob.HTTPCreated,
{'X-Amz-Copy-Source': '/bucket/'})
self.assertEquals(code, 'InvalidArgument')
self.assertEqual(code, 'InvalidArgument')
code = self._test_method_error(
'PUT', '/bucket/object',
swob.HTTPCreated,
{'X-Amz-Copy-Source': '/src_bucket/src_object',
'X-Amz-Copy-Source-Range': 'bytes=0-0'})
self.assertEquals(code, 'InvalidArgument')
self.assertEqual(code, 'InvalidArgument')
code = self._test_method_error('PUT', '/bucket/object',
swob.HTTPRequestTimeout)
self.assertEquals(code, 'RequestTimeout')
self.assertEqual(code, 'RequestTimeout')
@s3acl
def test_object_PUT(self):
@ -418,13 +418,13 @@ class TestSwift3Obj(Swift3TestCase):
req.date = datetime.now()
req.content_type = 'text/plain'
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
# Check that swift3 returns an etag header.
self.assertEquals(headers['etag'], '"%s"' % etag)
self.assertEqual(headers['etag'], '"%s"' % etag)
_, _, headers = self.swift.calls_with_headers[-1]
# Check that swift3 converts a Content-MD5 header into an etag.
self.assertEquals(headers['etag'], etag)
self.assertEqual(headers['etag'], etag)
def test_object_PUT_headers(self):
content_md5 = self.etag.decode('hex').encode('base64').strip()
@ -455,16 +455,16 @@ class TestSwift3Obj(Swift3TestCase):
_, _, headers = self.swift.calls_with_headers[-1]
# Check that swift3 converts a Content-MD5 header into an etag.
self.assertEquals(headers['ETag'], self.etag)
self.assertEquals(headers['X-Object-Meta-Something'], 'oh hai')
self.assertEquals(headers['X-Object-Meta-Unreadable-Prefix'],
'=?UTF-8?Q?=04w?=')
self.assertEquals(headers['X-Object-Meta-Unreadable-Suffix'],
'=?UTF-8?Q?h=04?=')
self.assertEquals(headers['X-Object-Meta-Lots-Of-Unprintable'],
'=?UTF-8?B?BAQEBAQ=?=')
self.assertEquals(headers['X-Copy-From'], '/some/source')
self.assertEquals(headers['Content-Length'], '0')
self.assertEqual(headers['ETag'], self.etag)
self.assertEqual(headers['X-Object-Meta-Something'], 'oh hai')
self.assertEqual(headers['X-Object-Meta-Unreadable-Prefix'],
'=?UTF-8?Q?=04w?=')
self.assertEqual(headers['X-Object-Meta-Unreadable-Suffix'],
'=?UTF-8?Q?h=04?=')
self.assertEqual(headers['X-Object-Meta-Lots-Of-Unprintable'],
'=?UTF-8?B?BAQEBAQ=?=')
self.assertEqual(headers['X-Copy-From'], '/some/source')
self.assertEqual(headers['Content-Length'], '0')
def _test_object_PUT_copy(self, head_resp, put_header=None,
src_path='/some/source', timestamp=None):
@ -516,17 +516,18 @@ class TestSwift3Obj(Swift3TestCase):
status, headers, body = self._test_object_PUT_copy(
swob.HTTPOk, put_header={'Date': date_header},
timestamp=timestamp)
self.assertEquals(status.split()[0], '200')
self.assertEquals(headers['Content-Type'], 'application/xml')
self.assertEqual(status.split()[0], '200')
self.assertEqual(headers['Content-Type'], 'application/xml')
self.assertTrue(headers.get('etag') is None)
self.assertTrue(headers.get('x-amz-meta-something') is None)
elem = fromstring(body, 'CopyObjectResult')
self.assertEquals(elem.find('LastModified').text, last_modified)
self.assertEquals(elem.find('ETag').text, '"%s"' % self.etag)
self.assertEqual(elem.find('LastModified').text, last_modified)
self.assertEqual(elem.find('ETag').text, '"%s"' % self.etag)
_, _, headers = self.swift.calls_with_headers[-1]
self.assertEquals(headers['X-Copy-From'], '/some/source')
self.assertEquals(headers['Content-Length'], '0')
self.assertEqual(headers['X-Copy-From'], '/some/source')
self.assertEqual(headers['Content-Length'], '0')
@s3acl
def test_object_PUT_copy_no_slash(self):
@ -538,44 +539,44 @@ class TestSwift3Obj(Swift3TestCase):
status, headers, body = self._test_object_PUT_copy(
swob.HTTPOk, src_path='some/source',
put_header={'Date': date_header}, timestamp=timestamp)
self.assertEquals(status.split()[0], '200')
self.assertEquals(headers['Content-Type'], 'application/xml')
self.assertEqual(status.split()[0], '200')
self.assertEqual(headers['Content-Type'], 'application/xml')
self.assertTrue(headers.get('etag') is None)
self.assertTrue(headers.get('x-amz-meta-something') is None)
elem = fromstring(body, 'CopyObjectResult')
self.assertEquals(elem.find('LastModified').text, last_modified)
self.assertEquals(elem.find('ETag').text, '"%s"' % self.etag)
self.assertEqual(elem.find('LastModified').text, last_modified)
self.assertEqual(elem.find('ETag').text, '"%s"' % self.etag)
_, _, headers = self.swift.calls_with_headers[-1]
self.assertEquals(headers['X-Copy-From'], '/some/source')
self.assertEquals(headers['Content-Length'], '0')
self.assertEqual(headers['X-Copy-From'], '/some/source')
self.assertEqual(headers['Content-Length'], '0')
@s3acl
def test_object_PUT_copy_self(self):
status, headers, body = \
self._test_object_PUT_copy_self(swob.HTTPOk)
self.assertEquals(status.split()[0], '400')
self.assertEqual(status.split()[0], '400')
elem = fromstring(body, 'Error')
err_msg = ("This copy request is illegal because it is trying to copy "
"an object to itself without changing the object's "
"metadata, storage class, website redirect location or "
"encryption attributes.")
self.assertEquals(elem.find('Code').text, 'InvalidRequest')
self.assertEquals(elem.find('Message').text, err_msg)
self.assertEqual(elem.find('Code').text, 'InvalidRequest')
self.assertEqual(elem.find('Message').text, err_msg)
@s3acl
def test_object_PUT_copy_self_metadata_copy(self):
header = {'x-amz-metadata-directive': 'COPY'}
status, headers, body = \
self._test_object_PUT_copy_self(swob.HTTPOk, header)
self.assertEquals(status.split()[0], '400')
self.assertEqual(status.split()[0], '400')
elem = fromstring(body, 'Error')
err_msg = ("This copy request is illegal because it is trying to copy "
"an object to itself without changing the object's "
"metadata, storage class, website redirect location or "
"encryption attributes.")
self.assertEquals(elem.find('Code').text, 'InvalidRequest')
self.assertEquals(elem.find('Message').text, err_msg)
self.assertEqual(elem.find('Code').text, 'InvalidRequest')
self.assertEqual(elem.find('Message').text, err_msg)
@s3acl
def test_object_PUT_copy_self_metadata_replace(self):
@ -586,16 +587,16 @@ class TestSwift3Obj(Swift3TestCase):
'Date': date_header}
status, headers, body = self._test_object_PUT_copy_self(
swob.HTTPOk, header, timestamp=timestamp)
self.assertEquals(status.split()[0], '200')
self.assertEquals(headers['Content-Type'], 'application/xml')
self.assertEqual(status.split()[0], '200')
self.assertEqual(headers['Content-Type'], 'application/xml')
self.assertTrue(headers.get('etag') is None)
elem = fromstring(body, 'CopyObjectResult')
self.assertEquals(elem.find('LastModified').text, last_modified)
self.assertEquals(elem.find('ETag').text, '"%s"' % self.etag)
self.assertEqual(elem.find('LastModified').text, last_modified)
self.assertEqual(elem.find('ETag').text, '"%s"' % self.etag)
_, _, headers = self.swift.calls_with_headers[-1]
self.assertEquals(headers['X-Copy-From'], '/bucket/object')
self.assertEquals(headers['Content-Length'], '0')
self.assertEqual(headers['X-Copy-From'], '/bucket/object')
self.assertEqual(headers['Content-Length'], '0')
@s3acl
def test_object_PUT_copy_headers_error(self):
@ -607,26 +608,26 @@ class TestSwift3Obj(Swift3TestCase):
status, header, body = \
self._test_object_PUT_copy(swob.HTTPPreconditionFailed,
header)
self.assertEquals(self._get_error_code(body), 'PreconditionFailed')
self.assertEqual(self._get_error_code(body), 'PreconditionFailed')
header = {'X-Amz-Copy-Source-If-None-Match': etag}
status, header, body = \
self._test_object_PUT_copy(swob.HTTPNotModified,
header)
self.assertEquals(self._get_error_code(body), 'PreconditionFailed')
self.assertEqual(self._get_error_code(body), 'PreconditionFailed')
header = {'X-Amz-Copy-Source-If-Modified-Since': last_modified_since}
status, header, body = \
self._test_object_PUT_copy(swob.HTTPNotModified,
header)
self.assertEquals(self._get_error_code(body), 'PreconditionFailed')
self.assertEqual(self._get_error_code(body), 'PreconditionFailed')
header = \
{'X-Amz-Copy-Source-If-Unmodified-Since': last_modified_since}
status, header, body = \
self._test_object_PUT_copy(swob.HTTPPreconditionFailed,
header)
self.assertEquals(self._get_error_code(body), 'PreconditionFailed')
self.assertEqual(self._get_error_code(body), 'PreconditionFailed')
def test_object_PUT_copy_headers_with_match(self):
etag = '7dfa07a8e59ddbcd1dc84d4c4f82aea1'
@ -637,14 +638,14 @@ class TestSwift3Obj(Swift3TestCase):
'Date': self.get_date_header()}
status, header, body = \
self._test_object_PUT_copy(swob.HTTPOk, header)
self.assertEquals(status.split()[0], '200')
self.assertEquals(len(self.swift.calls_with_headers), 2)
self.assertEqual(status.split()[0], '200')
self.assertEqual(len(self.swift.calls_with_headers), 2)
_, _, headers = self.swift.calls_with_headers[-1]
self.assertTrue(headers.get('If-Match') is None)
self.assertTrue(headers.get('If-Modified-Since') is None)
_, _, headers = self.swift.calls_with_headers[0]
self.assertEquals(headers['If-Match'], etag)
self.assertEquals(headers['If-Modified-Since'], last_modified_since)
self.assertEqual(headers['If-Match'], etag)
self.assertEqual(headers['If-Modified-Since'], last_modified_since)
@s3acl(s3acl_only=True)
def test_object_PUT_copy_headers_with_match_and_s3acl(self):
@ -657,8 +658,8 @@ class TestSwift3Obj(Swift3TestCase):
status, header, body = \
self._test_object_PUT_copy(swob.HTTPOk, header)
self.assertEquals(status.split()[0], '200')
self.assertEquals(len(self.swift.calls_with_headers), 3)
self.assertEqual(status.split()[0], '200')
self.assertEqual(len(self.swift.calls_with_headers), 3)
# After the check of the copy source in the case of s3acl is valid,
# Swift3 check the bucket write permissions of the destination.
_, _, headers = self.swift.calls_with_headers[-2]
@ -668,8 +669,8 @@ class TestSwift3Obj(Swift3TestCase):
self.assertTrue(headers.get('If-Match') is None)
self.assertTrue(headers.get('If-Modified-Since') is None)
_, _, headers = self.swift.calls_with_headers[0]
self.assertEquals(headers['If-Match'], etag)
self.assertEquals(headers['If-Modified-Since'], last_modified_since)
self.assertEqual(headers['If-Match'], etag)
self.assertEqual(headers['If-Modified-Since'], last_modified_since)
def test_object_PUT_copy_headers_with_not_match(self):
etag = '7dfa07a8e59ddbcd1dc84d4c4f82aea1'
@ -681,14 +682,14 @@ class TestSwift3Obj(Swift3TestCase):
status, header, body = \
self._test_object_PUT_copy(swob.HTTPOk, header)
self.assertEquals(status.split()[0], '200')
self.assertEquals(len(self.swift.calls_with_headers), 2)
self.assertEqual(status.split()[0], '200')
self.assertEqual(len(self.swift.calls_with_headers), 2)
_, _, headers = self.swift.calls_with_headers[-1]
self.assertTrue(headers.get('If-None-Match') is None)
self.assertTrue(headers.get('If-Unmodified-Since') is None)
_, _, headers = self.swift.calls_with_headers[0]
self.assertEquals(headers['If-None-Match'], etag)
self.assertEquals(headers['If-Unmodified-Since'], last_modified_since)
self.assertEqual(headers['If-None-Match'], etag)
self.assertEqual(headers['If-Unmodified-Since'], last_modified_since)
@s3acl(s3acl_only=True)
def test_object_PUT_copy_headers_with_not_match_and_s3acl(self):
@ -700,48 +701,48 @@ class TestSwift3Obj(Swift3TestCase):
'Date': self.get_date_header()}
status, header, body = \
self._test_object_PUT_copy(swob.HTTPOk, header)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
# After the check of the copy source in the case of s3acl is valid,
# Swift3 check the bucket write permissions of the destination.
self.assertEquals(len(self.swift.calls_with_headers), 3)
self.assertEqual(len(self.swift.calls_with_headers), 3)
_, _, headers = self.swift.calls_with_headers[-1]
self.assertTrue(headers.get('If-None-Match') is None)
self.assertTrue(headers.get('If-Unmodified-Since') is None)
_, _, headers = self.swift.calls_with_headers[0]
self.assertEquals(headers['If-None-Match'], etag)
self.assertEquals(headers['If-Unmodified-Since'], last_modified_since)
self.assertEqual(headers['If-None-Match'], etag)
self.assertEqual(headers['If-Unmodified-Since'], last_modified_since)
@s3acl
def test_object_POST_error(self):
code = self._test_method_error('POST', '/bucket/object', None)
self.assertEquals(code, 'NotImplemented')
self.assertEqual(code, 'NotImplemented')
@s3acl
def test_object_DELETE_error(self):
code = self._test_method_error('DELETE', '/bucket/object',
swob.HTTPUnauthorized)
self.assertEquals(code, 'SignatureDoesNotMatch')
self.assertEqual(code, 'SignatureDoesNotMatch')
code = self._test_method_error('DELETE', '/bucket/object',
swob.HTTPForbidden)
self.assertEquals(code, 'AccessDenied')
self.assertEqual(code, 'AccessDenied')
code = self._test_method_error('DELETE', '/bucket/object',
swob.HTTPServerError)
self.assertEquals(code, 'InternalError')
self.assertEqual(code, 'InternalError')
code = self._test_method_error('DELETE', '/bucket/object',
swob.HTTPServiceUnavailable)
self.assertEquals(code, 'InternalError')
self.assertEqual(code, 'InternalError')
with patch('swift3.request.get_container_info',
return_value={'status': 204}):
code = self._test_method_error('DELETE', '/bucket/object',
swob.HTTPNotFound)
self.assertEquals(code, 'NoSuchKey')
self.assertEqual(code, 'NoSuchKey')
with patch('swift3.request.get_container_info',
return_value={'status': 404}):
code = self._test_method_error('DELETE', '/bucket/object',
swob.HTTPNotFound)
self.assertEquals(code, 'NoSuchBucket')
self.assertEqual(code, 'NoSuchBucket')
@s3acl
@patch('swift3.cfg.CONF.allow_multipart_uploads', False)
@ -751,14 +752,14 @@ class TestSwift3Obj(Swift3TestCase):
headers={'Authorization': 'AWS test:tester:hmac',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '204')
self.assertEqual(status.split()[0], '204')
self.assertNotIn(('HEAD', '/v1/AUTH_test/bucket/object'),
self.swift.calls)
self.assertIn(('DELETE', '/v1/AUTH_test/bucket/object'),
self.swift.calls)
_, path = self.swift.calls[-1]
self.assertEquals(path.count('?'), 0)
self.assertEqual(path.count('?'), 0)
@s3acl
def test_object_DELETE_multipart(self):
@ -767,14 +768,14 @@ class TestSwift3Obj(Swift3TestCase):
headers={'Authorization': 'AWS test:tester:hmac',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '204')
self.assertEqual(status.split()[0], '204')
self.assertIn(('HEAD', '/v1/AUTH_test/bucket/object'),
self.swift.calls)
self.assertIn(('DELETE', '/v1/AUTH_test/bucket/object'),
self.swift.calls)
_, path = self.swift.calls[-1]
self.assertEquals(path.count('?'), 0)
self.assertEqual(path.count('?'), 0)
@s3acl
def test_slo_object_DELETE(self):
@ -804,7 +805,7 @@ class TestSwift3Obj(Swift3TestCase):
for q in query_string.split('&'):
key, arg = q.split('=')
query[key] = arg
self.assertEquals(query['multipart-manifest'], 'delete')
self.assertEqual(query['multipart-manifest'], 'delete')
self.assertNotIn('Content-Type', headers)
def _test_object_for_s3acl(self, method, account):
@ -826,38 +827,38 @@ class TestSwift3Obj(Swift3TestCase):
def test_object_GET_without_permission(self):
status, headers, body = self._test_object_for_s3acl('GET',
'test:other')
self.assertEquals(self._get_error_code(body), 'AccessDenied')
self.assertEqual(self._get_error_code(body), 'AccessDenied')
@s3acl(s3acl_only=True)
def test_object_GET_with_read_permission(self):
status, headers, body = self._test_object_for_s3acl('GET',
'test:read')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
@s3acl(s3acl_only=True)
def test_object_GET_with_fullcontrol_permission(self):
status, headers, body = \
self._test_object_for_s3acl('GET', 'test:full_control')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
@s3acl(s3acl_only=True)
def test_object_PUT_without_permission(self):
status, headers, body = self._test_object_for_s3acl('PUT',
'test:other')
self.assertEquals(self._get_error_code(body), 'AccessDenied')
self.assertEqual(self._get_error_code(body), 'AccessDenied')
@s3acl(s3acl_only=True)
def test_object_PUT_with_owner_permission(self):
status, headers, body = self._test_object_for_s3acl('PUT',
'test:tester')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
@s3acl(s3acl_only=True)
def test_object_PUT_with_write_permission(self):
account = 'test:other'
self._test_set_container_permission(account, 'WRITE')
status, headers, body = self._test_object_for_s3acl('PUT', account)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
@s3acl(s3acl_only=True)
def test_object_PUT_with_fullcontrol_permission(self):
@ -865,20 +866,20 @@ class TestSwift3Obj(Swift3TestCase):
self._test_set_container_permission(account, 'FULL_CONTROL')
status, headers, body = \
self._test_object_for_s3acl('PUT', account)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
@s3acl(s3acl_only=True)
def test_object_DELETE_without_permission(self):
account = 'test:other'
status, headers, body = self._test_object_for_s3acl('DELETE',
account)
self.assertEquals(self._get_error_code(body), 'AccessDenied')
self.assertEqual(self._get_error_code(body), 'AccessDenied')
@s3acl(s3acl_only=True)
def test_object_DELETE_with_owner_permission(self):
status, headers, body = self._test_object_for_s3acl('DELETE',
'test:tester')
self.assertEquals(status.split()[0], '204')
self.assertEqual(status.split()[0], '204')
@s3acl(s3acl_only=True)
def test_object_DELETE_with_write_permission(self):
@ -886,14 +887,14 @@ class TestSwift3Obj(Swift3TestCase):
self._test_set_container_permission(account, 'WRITE')
status, headers, body = self._test_object_for_s3acl('DELETE',
account)
self.assertEquals(status.split()[0], '204')
self.assertEqual(status.split()[0], '204')
@s3acl(s3acl_only=True)
def test_object_DELETE_with_fullcontrol_permission(self):
account = 'test:other'
self._test_set_container_permission(account, 'FULL_CONTROL')
status, headers, body = self._test_object_for_s3acl('DELETE', account)
self.assertEquals(status.split()[0], '204')
self.assertEqual(status.split()[0], '204')
def _test_object_copy_for_s3acl(self, account, src_permission=None,
src_path='/src_bucket/src_obj'):
@ -920,32 +921,32 @@ class TestSwift3Obj(Swift3TestCase):
def test_object_PUT_copy_with_owner_permission(self):
status, headers, body = \
self._test_object_copy_for_s3acl('test:tester')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
@s3acl(s3acl_only=True)
def test_object_PUT_copy_with_fullcontrol_permission(self):
status, headers, body = \
self._test_object_copy_for_s3acl('test:full_control',
'FULL_CONTROL')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
@s3acl(s3acl_only=True)
def test_object_PUT_copy_with_grantee_permission(self):
status, headers, body = \
self._test_object_copy_for_s3acl('test:write', 'READ')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
@s3acl(s3acl_only=True)
def test_object_PUT_copy_without_src_obj_permission(self):
status, headers, body = \
self._test_object_copy_for_s3acl('test:write')
self.assertEquals(status.split()[0], '403')
self.assertEqual(status.split()[0], '403')
@s3acl(s3acl_only=True)
def test_object_PUT_copy_without_dst_container_permission(self):
status, headers, body = \
self._test_object_copy_for_s3acl('test:other', 'READ')
self.assertEquals(status.split()[0], '403')
self.assertEqual(status.split()[0], '403')
@s3acl(s3acl_only=True)
def test_object_PUT_copy_empty_src_path(self):
@ -953,7 +954,7 @@ class TestSwift3Obj(Swift3TestCase):
swob.HTTPPreconditionFailed, {}, None)
status, headers, body = self._test_object_copy_for_s3acl(
'test:write', 'READ', src_path='')
self.assertEquals(status.split()[0], '400')
self.assertEqual(status.split()[0], '400')
class TestSwift3ObjNonUTC(TestSwift3Obj):

48
swift3/test/unit/test_request.py

@ -126,8 +126,8 @@ class TestRequest(Swift3TestCase):
def test_get_response_without_match_ACL_MAP(self):
with self.assertRaises(Exception) as e:
self._test_get_response('POST', req_klass=S3AclRequest)
self.assertEquals(e.exception.message,
'No permission to be checked exists')
self.assertEqual(e.exception.message,
'No permission to be checked exists')
def test_get_response_without_duplication_HEAD_request(self):
obj = 'object'
@ -188,11 +188,11 @@ class TestRequest(Swift3TestCase):
s3req = create_s3request_with_param('max-keys', '1')
# a param in the range
self.assertEquals(s3req.get_validated_param('max-keys', 1000, 1000), 1)
self.assertEquals(s3req.get_validated_param('max-keys', 0, 1), 1)
self.assertEqual(s3req.get_validated_param('max-keys', 1000, 1000), 1)
self.assertEqual(s3req.get_validated_param('max-keys', 0, 1), 1)
# a param in the out of the range
self.assertEquals(s3req.get_validated_param('max-keys', 0, 0), 0)
self.assertEqual(s3req.get_validated_param('max-keys', 0, 0), 0)
# a param in the out of the integer range
s3req = create_s3request_with_param('max-keys', '1' * 30)
@ -200,7 +200,7 @@ class TestRequest(Swift3TestCase):
s3req.get_validated_param('max-keys', 1)
self.assertTrue(
'not an integer or within integer range' in result.exception.body)
self.assertEquals(
self.assertEqual(
result.exception.headers['content-type'], 'application/xml')
# a param is negative integer
@ -209,7 +209,7 @@ class TestRequest(Swift3TestCase):
s3req.get_validated_param('max-keys', 1)
self.assertTrue(
'must be an integer between 0 and' in result.exception.body)
self.assertEquals(
self.assertEqual(
result.exception.headers['content-type'], 'application/xml')
# a param is not integer
@ -218,7 +218,7 @@ class TestRequest(Swift3TestCase):
s3req.get_validated_param('max-keys', 1)
self.assertTrue(
'not an integer or within integer range' in result.exception.body)
self.assertEquals(
self.assertEqual(
result.exception.headers['content-type'], 'application/xml')
def test_authenticate_delete_Authorization_from_s3req_headers(self):
@ -234,7 +234,7 @@ class TestRequest(Swift3TestCase):
s3_req = S3AclRequest(req.environ, MagicMock())
self.assertTrue('HTTP_AUTHORIZATION' not in s3_req.environ)
self.assertTrue('Authorization' not in s3_req.headers)
self.assertEquals(s3_req.token, 'token')
self.assertEqual(s3_req.token, 'token')
def test_to_swift_req_Authorization_not_exist_in_swreq_headers(self):
container = 'bucket'
@ -253,7 +253,7 @@ class TestRequest(Swift3TestCase):
sw_req = s3_req.to_swift_req(method, container, obj)
self.assertNotIn('HTTP_AUTHORIZATION', sw_req.environ)
self.assertNotIn('Authorization', sw_req.headers)
self.assertEquals(sw_req.headers['X-Auth-Token'], 'token')
self.assertEqual(sw_req.headers['X-Auth-Token'], 'token')
def test_to_swift_req_subrequest_proxy_access_log(self):
container = 'bucket'
@ -304,18 +304,18 @@ class TestRequest(Swift3TestCase):
# first, call get_response('HEAD')
info = s3_req.get_container_info(self.app)
self.assertTrue('status' in info) # sanity
self.assertEquals(204, info['status']) # sanity
self.assertEquals('foo', info['read_acl']) # sanity
self.assertEquals('5', info['object_count']) # sanity
self.assertEquals({'foo': 'bar'}, info['meta']) # sanity
self.assertEqual(204, info['status']) # sanity
self.assertEqual('foo', info['read_acl']) # sanity
self.assertEqual('5', info['object_count']) # sanity
self.assertEqual({'foo': 'bar'}, info['meta']) # sanity
with patch('swift3.request.get_container_info',
return_value={'status': 204}) as mock_info:
# Then all calls goes to get_container_info
for x in xrange(10):
info = s3_req.get_container_info(self.swift)
self.assertTrue('status' in info) # sanity
self.assertEquals(204, info['status']) # sanity
self.assertEquals(10, mock_info.call_count)
self.assertEqual(204, info['status']) # sanity
self.assertEqual(10, mock_info.call_count)
expected_errors = [(404, NoSuchBucket), (0, InternalError)]
for status, expected_error in expected_errors:
@ -331,8 +331,8 @@ class TestRequest(Swift3TestCase):
environ={'REQUEST_METHOD': 'HEAD'},
headers={'Authorization': 'AWS test:tester:hmac'})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '403')
self.assertEquals(body, '')
self.assertEqual(status.split()[0], '403')
self.assertEqual(body, '')
def test_date_header_expired(self):
self.swift.register('HEAD', '/v1/AUTH_test/nojunk', swob.HTTPNotFound,
@ -343,8 +343,8 @@ class TestRequest(Swift3TestCase):
'Date': 'Fri, 01 Apr 2014 12:00:00 GMT'})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '403')
self.assertEquals(body, '')
self.assertEqual(status.split()[0], '403')
self.assertEqual(body, '')
def test_date_header_with_x_amz_date_valid(self):
self.swift.register('HEAD', '/v1/AUTH_test/nojunk', swob.HTTPNotFound,
@ -356,8 +356,8 @@ class TestRequest(Swift3TestCase):
'x-amz-date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '404')
self.assertEquals(body, '')
self.assertEqual(status.split()[0], '404')
self.assertEqual(body, '')
def test_date_header_with_x_amz_date_expired(self):
self.swift.register('HEAD', '/v1/AUTH_test/nojunk', swob.HTTPNotFound,
@ -370,8 +370,8 @@ class TestRequest(Swift3TestCase):
'Fri, 01 Apr 2014 12:00:00 GMT'})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '403')
self.assertEquals(body, '')
self.assertEqual(status.split()[0], '403')
self.assertEqual(body, '')
def _test_request_timestamp_sigv4(self, date_header):
# signature v4 here

84
swift3/test/unit/test_s3_acl.py

@ -177,7 +177,7 @@ class TestSwift3S3Acl(Swift3TestCase):
Owner(id='test:other',
name='test:other')).elem()))
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'AccessDenied')
self.assertEqual(self._get_error_code(body), 'AccessDenied')
def test_object_acl_PUT_xml_error(self):
req = Request.blank('/bucket/object?acl',
@ -186,7 +186,7 @@ class TestSwift3S3Acl(Swift3TestCase):
'Date': self.get_date_header()},
body="invalid xml")
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'MalformedACLError')
self.assertEqual(self._get_error_code(body), 'MalformedACLError')
def test_canned_acl_private(self):
req = Request.blank('/bucket/object?acl',
@ -195,7 +195,7 @@ class TestSwift3S3Acl(Swift3TestCase):
'Date': self.get_date_header(),
'x-amz-acl': 'private'})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def test_canned_acl_public_read(self):
req = Request.blank('/bucket/object?acl',
@ -204,7 +204,7 @@ class TestSwift3S3Acl(Swift3TestCase):
'Date': self.get_date_header(),
'x-amz-acl': 'public-read'})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def test_canned_acl_public_read_write(self):
req = Request.blank('/bucket/object?acl',
@ -213,7 +213,7 @@ class TestSwift3S3Acl(Swift3TestCase):
'Date': self.get_date_header(),
'x-amz-acl': 'public-read-write'})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def test_canned_acl_authenticated_read(self):
req = Request.blank('/bucket/object?acl',
@ -222,7 +222,7 @@ class TestSwift3S3Acl(Swift3TestCase):
'Date': self.get_date_header(),
'x-amz-acl': 'authenticated-read'})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def test_canned_acl_bucket_owner_read(self):
req = Request.blank('/bucket/object?acl',
@ -231,7 +231,7 @@ class TestSwift3S3Acl(Swift3TestCase):
'Date': self.get_date_header(),
'x-amz-acl': 'bucket-owner-read'})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def test_canned_acl_bucket_owner_full_control(self):
req = Request.blank('/bucket/object?acl',
@ -240,7 +240,7 @@ class TestSwift3S3Acl(Swift3TestCase):
'Date': self.get_date_header(),
'x-amz-acl': 'bucket-owner-full-control'})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def test_invalid_canned_acl(self):
req = Request.blank('/bucket/object?acl',
@ -249,7 +249,7 @@ class TestSwift3S3Acl(Swift3TestCase):
'Date': self.get_date_header(),
'x-amz-acl': 'invalid'})
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'InvalidArgument')
self.assertEqual(self._get_error_code(body), 'InvalidArgument')
def _test_grant_header(self, permission):
req = Request.blank('/bucket/object?acl',
@ -262,27 +262,27 @@ class TestSwift3S3Acl(Swift3TestCase):
def test_grant_read(self):
status, headers, body = self._test_grant_header('read')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def test_grant_write(self):
status, headers, body = self._test_grant_header('write')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def test_grant_read_acp(self):
status, headers, body = self._test_grant_header('read-acp')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def test_grant_write_acp(self):
status, headers, body = self._test_grant_header('write-acp')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def test_grant_full_control(self):
status, headers, body = self._test_grant_header('full-control')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def test_grant_invalid_permission(self):
status, headers, body = self._test_grant_header('invalid')
self.assertEquals(self._get_error_code(body), 'MissingSecurityHeader')
self.assertEqual(self._get_error_code(body), 'MissingSecurityHeader')
def test_grant_with_both_header_and_xml(self):
req = Request.blank('/bucket/object?acl',
@ -296,7 +296,7 @@ class TestSwift3S3Acl(Swift3TestCase):
Owner(id='test:tester',
name='test:tester')).elem()))
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'UnexpectedContent')
self.assertEqual(self._get_error_code(body), 'UnexpectedContent')
def test_grant_with_both_header_and_canned_acl(self):
req = Request.blank('/bucket/object?acl',
@ -307,7 +307,7 @@ class TestSwift3S3Acl(Swift3TestCase):
'id=test:tester',
'x-amz-acl': 'public-read'})
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'InvalidRequest')
self.assertEqual(self._get_error_code(body), 'InvalidRequest')
def test_grant_email(self):
req = Request.blank('/bucket/object?acl',
@ -316,7 +316,7 @@ class TestSwift3S3Acl(Swift3TestCase):
'Date': self.get_date_header(),
'x-amz-grant-read': 'emailAddress=a@b.c'})
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'NotImplemented')
self.assertEqual(self._get_error_code(body), 'NotImplemented')
def test_grant_email_xml(self):
grantee = Element('Grantee', nsmap={'xsi': XMLNS_XSI})
@ -329,7 +329,7 @@ class TestSwift3S3Acl(Swift3TestCase):
'Date': self.get_date_header()},
body=xml)
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'NotImplemented')
self.assertEqual(self._get_error_code(body), 'NotImplemented')
def test_grant_invalid_group_xml(self):
grantee = Element('Grantee', nsmap={'xsi': XMLNS_XSI})
@ -341,7 +341,7 @@ class TestSwift3S3Acl(Swift3TestCase):
'Date': self.get_date_header()},
body=xml)
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'MalformedACLError')
self.assertEqual(self._get_error_code(body), 'MalformedACLError')
def test_grant_authenticated_users(self):
req = Request.blank('/bucket/object?acl',
@ -352,7 +352,7 @@ class TestSwift3S3Acl(Swift3TestCase):
'uri="http://acs.amazonaws.com/groups/'
'global/AuthenticatedUsers"'})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def test_grant_all_users(self):
req = Request.blank('/bucket/object?acl',
@ -363,7 +363,7 @@ class TestSwift3S3Acl(Swift3TestCase):
'uri="http://acs.amazonaws.com/groups/'
'global/AllUsers"'})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def test_grant_invalid_uri(self):
req = Request.blank('/bucket/object?acl',
@ -373,7 +373,7 @@ class TestSwift3S3Acl(Swift3TestCase):
'x-amz-grant-read':
'uri="http://localhost/"'})
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'InvalidArgument')
self.assertEqual(self._get_error_code(body), 'InvalidArgument')
def test_grant_invalid_uri_xml(self):
grantee = Element('Grantee', nsmap={'xsi': XMLNS_XSI})
@ -387,7 +387,7 @@ class TestSwift3S3Acl(Swift3TestCase):
'Date': self.get_date_header()},
body=xml)
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'InvalidArgument')
self.assertEqual(self._get_error_code(body), 'InvalidArgument')
def test_grant_invalid_target(self):
req = Request.blank('/bucket/object?acl',
@ -396,7 +396,7 @@ class TestSwift3S3Acl(Swift3TestCase):
'Date': self.get_date_header(),
'x-amz-grant-read': 'key=value'})
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'InvalidArgument')
self.assertEqual(self._get_error_code(body), 'InvalidArgument')
def _test_bucket_acl_GET(self, account):
req = Request.blank('/bucket?acl',
@ -407,19 +407,19 @@ class TestSwift3S3Acl(Swift3TestCase):
def test_bucket_acl_GET_without_permission(self):
status, headers, body = self._test_bucket_acl_GET('test:other')
self.assertEquals(self._get_error_code(body), 'AccessDenied')
self.assertEqual(self._get_error_code(body), 'AccessDenied')
def test_bucket_acl_GET_with_read_acp_permission(self):
status, headers, body = self._test_bucket_acl_GET('test:read_acp')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def test_bucket_acl_GET_with_fullcontrol_permission(self):
status, headers, body = self._test_bucket_acl_GET('test:full_control')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def test_bucket_acl_GET_with_owner_permission(self):
status, headers, body = self._test_bucket_acl_GET('test:tester')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def _test_bucket_acl_PUT(self, account, permission='FULL_CONTROL'):
acl = ACL(self.default_owner, [Grant(User(account), permission)])
@ -433,19 +433,19 @@ class TestSwift3S3Acl(Swift3TestCase):
def test_bucket_acl_PUT_without_permission(self):
status, headers, body = self._test_bucket_acl_PUT('test:other')
self.assertEquals(self._get_error_code(body), 'AccessDenied')
self.assertEqual(self._get_error_code(body), 'AccessDenied')
def test_bucket_acl_PUT_with_write_acp_permission(self):
status, headers, body = self._test_bucket_acl_PUT('test:write_acp')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def test_bucket_acl_PUT_with_fullcontrol_permission(self):
status, headers, body = self._test_bucket_acl_PUT('test:full_control')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def test_bucket_acl_PUT_with_owner_permission(self):
status, headers, body = self._test_bucket_acl_PUT('test:tester')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def _test_object_acl_GET(self, account):
req = Request.blank('/bucket/object?acl',
@ -456,19 +456,19 @@ class TestSwift3S3Acl(Swift3TestCase):
def test_object_acl_GET_without_permission(self):
status, headers, body = self._test_object_acl_GET('test:other')
self.assertEquals(self._get_error_code(body), 'AccessDenied')
self.assertEqual(self._get_error_code(body), 'AccessDenied')
def test_object_acl_GET_with_read_acp_permission(self):
status, headers, body = self._test_object_acl_GET('test:read_acp')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def test_object_acl_GET_with_fullcontrol_permission(self):
status, headers, body = self._test_object_acl_GET('test:full_control')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def test_object_acl_GET_with_owner_permission(self):
status, headers, body = self._test_object_acl_GET('test:tester')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def _test_object_acl_PUT(self, account, permission='FULL_CONTROL'):
acl = ACL(self.default_owner, [Grant(User(account), permission)])
@ -482,19 +482,19 @@ class TestSwift3S3Acl(Swift3TestCase):
def test_object_acl_PUT_without_permission(self):
status, headers, body = self._test_object_acl_PUT('test:other')
self.assertEquals(self._get_error_code(body), 'AccessDenied')
self.assertEqual(self._get_error_code(body), 'AccessDenied')
def test_object_acl_PUT_with_write_acp_permission(self):
status, headers, body = self._test_object_acl_PUT('test:write_acp')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def test_object_acl_PUT_with_fullcontrol_permission(self):
status, headers, body = self._test_object_acl_PUT('test:full_control')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def test_object_acl_PUT_with_owner_permission(self):
status, headers, body = self._test_object_acl_PUT('test:tester')
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
def test_s3acl_decorator(self):
@s3acl
@ -529,7 +529,7 @@ class TestSwift3S3Acl(Swift3TestCase):
self.assertRaises(TypeError, fake_class.s3acl_error)
self.assertRaises(AssertionError, fake_class.s3acl_assert_fail)
self.assertRaises(TypeError, fake_class.s3acl_s3only_error)
self.assertEquals(None, fake_class.s3acl_s3only_no_error())
self.assertEqual(None, fake_class.s3acl_s3only_no_error())
if __name__ == '__main__':
unittest.main()

40
swift3/test/unit/test_service.py

@ -52,11 +52,11 @@ class TestSwift3Service(Swift3TestCase):
def test_service_GET_error(self):
code = self._test_method_error('GET', '', swob.HTTPUnauthorized)
self.assertEquals(code, 'SignatureDoesNotMatch')
self.assertEqual(code, 'SignatureDoesNotMatch')
code = self._test_method_error('GET', '', swob.HTTPForbidden)
self.assertEquals(code, 'AccessDenied')
self.assertEqual(code, 'AccessDenied')
code = self._test_method_error('GET', '', swob.HTTPServerError)
self.assertEquals(code, 'InternalError')
self.assertEqual(code, 'InternalError')
@s3acl
def test_service_GET(self):
@ -65,20 +65,20 @@ class TestSwift3Service(Swift3TestCase):
headers={'Authorization': 'AWS test:tester:hmac',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
elem = fromstring(body, 'ListAllMyBucketsResult')
all_buckets = elem.find('./Buckets')
buckets = all_buckets.iterchildren('Bucket')
listing = list(list(buckets)[0])
self.assertEquals(len(listing), 2)
self.assertEqual(len(listing), 2)
names = []
for b in all_buckets.iterchildren('Bucket'):
names.append(b.find('./Name').text)
self.assertEquals(len(names), len(self.buckets))
self.assertEqual(len(names), len(self.buckets))
for i in self.buckets:
self.assertTrue(i[0] in names)
@ -89,20 +89,20 @@ class TestSwift3Service(Swift3TestCase):
headers={'Authorization': 'AWS test:tester:hmac',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
elem = fromstring(body, 'ListAllMyBucketsResult')
all_buckets = elem.find('./Buckets')
buckets = all_buckets.iterchildren('Bucket')
listing = list(list(buckets)[0])
self.assertEquals(len(listing), 2)
self.assertEqual(len(listing), 2)
names = []
for b in all_buckets.iterchildren('Bucket'):
names.append(b.find('./Name').text)
self.assertEquals(len(names), len(self.buckets))
self.assertEqual(len(names), len(self.buckets))
for i in self.buckets:
self.assertTrue(i[0] in names)
@ -120,19 +120,19 @@ class TestSwift3Service(Swift3TestCase):
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
elem = fromstring(body, 'ListAllMyBucketsResult')
all_buckets = elem.find('./Buckets')
buckets = all_buckets.iterchildren('Bucket')
listing = list(list(buckets)[0])
self.assertEquals(len(listing), 2)
self.assertEqual(len(listing), 2)
names = []
for b in all_buckets.iterchildren('Bucket'):
names.append(b.find('./Name').text)
self.assertEquals(len(names), len(expected))
self.assertEqual(len(names), len(expected))
for i in expected:
self.assertTrue(i[0] in names)
@ -160,13 +160,13 @@ class TestSwift3Service(Swift3TestCase):
status, headers, body = \
self._test_service_GET_for_check_bucket_owner(bucket_list)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
elem = fromstring(body, 'ListAllMyBucketsResult')
resp_buckets = elem.find('./Buckets')
buckets = resp_buckets.iterchildren('Bucket')
self.assertEquals(len(list(buckets)), 0)
self.assertEqual(len(list(buckets)), 0)
@s3acl(s3acl_only=True)
def test_service_GET_without_owner_bucket(self):
@ -182,13 +182,13 @@ class TestSwift3Service(Swift3TestCase):
status, headers, body = \
self._test_service_GET_for_check_bucket_owner(bucket_list)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
elem = fromstring(body, 'ListAllMyBucketsResult')
resp_buckets = elem.find('./Buckets')
buckets = resp_buckets.iterchildren('Bucket')
self.assertEquals(len(list(buckets)), 0)
self.assertEqual(len(list(buckets)), 0)
@s3acl(s3acl_only=True)
def test_service_GET_bucekt_list(self):
@ -212,13 +212,13 @@ class TestSwift3Service(Swift3TestCase):
status, headers, body = \
self._test_service_GET_for_check_bucket_owner(bucket_list)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
elem = fromstring(body, 'ListAllMyBucketsResult')
resp_buckets = elem.find('./Buckets')
buckets = resp_buckets.iterchildren('Bucket')
listing = list(list(buckets)[0])
self.assertEquals(len(listing), 2)
self.assertEqual(len(listing), 2)
names = []
for b in resp_buckets.iterchildren('Bucket'):
@ -228,10 +228,10 @@ class TestSwift3Service(Swift3TestCase):
# bucket_list which mean requested user is owner.
expected_buckets = [b for i, b in enumerate(bucket_list)
if i % 3 == 0]
self.assertEquals(len(names), len(expected_buckets))
self.assertEqual(len(names), len(expected_buckets))
for i in expected_buckets:
self.assertTrue(i[0] in names)
self.assertEquals(len(self.swift.calls_with_headers), 11)
self.assertEqual(len(self.swift.calls_with_headers), 11)
if __name__ == '__main__':
unittest.main()

30
swift3/test/unit/test_subresource.py

@ -39,8 +39,8 @@ class TestSwift3Subresource(unittest.TestCase):
self.assertTrue('test:tester' in grantee)
self.assertTrue('test:tester2' not in grantee)
self.assertEquals(str(grantee), 'test:tester')
self.assertEquals(grantee.elem().find('./ID').text, 'test:tester')
self.assertEqual(str(grantee), 'test:tester')
self.assertEqual(grantee.elem().find('./ID').text, 'test:tester')
def test_acl_authenticated_users(self):
grantee = AuthenticatedUsers()
@ -48,7 +48,7 @@ class TestSwift3Subresource(unittest.TestCase):
self.assertTrue('test:tester' in grantee)
self.assertTrue('test:tester2' in grantee)
uri = 'http://acs.amazonaws.com/groups/global/AuthenticatedUsers'
self.assertEquals(grantee.elem().find('./URI').text, uri)
self.assertEqual(grantee.elem().find('./URI').text, uri)
def test_acl_all_users(self):
grantee = AllUsers()
@ -56,7 +56,7 @@ class TestSwift3Subresource(unittest.TestCase):
self.assertTrue('test:tester' in grantee)
self.assertTrue('test:tester2' in grantee)
uri = 'http://acs.amazonaws.com/groups/global/AllUsers'
self.assertEquals(grantee.elem().find('./URI').text, uri)
self.assertEqual(grantee.elem().find('./URI').text, uri)
def check_permission(self, acl, user_id, permission):
try:
@ -163,9 +163,9 @@ class TestSwift3Subresource(unittest.TestCase):
self.assertTrue(elem.find('./Owner') is not None)
self.assertTrue(elem.find('./AccessControlList') is not None)
grants = [e for e in elem.findall('./AccessControlList/Grant')]
self.assertEquals(len(grants), 1)
self.assertEquals(grants[0].find('./Grantee/ID').text, 'test:tester')
self.assertEquals(
self.assertEqual(len(grants), 1)
self.assertEqual(grants[0].find('./Grantee/ID').text, 'test:tester')
self.assertEqual(
grants[0].find('./Grantee/DisplayName').text, 'test:tester')
def test_acl_from_elem(self):
@ -302,7 +302,7 @@ class TestSwift3Subresource(unittest.TestCase):
acl = ACL.from_headers({'x-amz-acl': acl_str}, owner)
expected = grantee_map[acl_str]
self.assertEquals(len(acl.grants), len(expected)) # sanity
self.assertEqual(len(acl.grants), len(expected)) # sanity
# parse Grant object to permission and grantee
actual_grants = [(grant.permission, grant.grantee)
@ -312,22 +312,22 @@ class TestSwift3Subresource(unittest.TestCase):
for (expected_permission, expected_grantee), \
(permission, grantee) in assertions:
self.assertEquals(expected_permission, permission)
self.assertEqual(expected_permission, permission)
self.assertTrue(
isinstance(grantee, expected_grantee.__class__))
if isinstance(grantee, User):
self.assertEquals(expected_grantee.id, grantee.id)
self.assertEquals(expected_grantee.display_name,
grantee.display_name)
self.assertEqual(expected_grantee.id, grantee.id)
self.assertEqual(expected_grantee.display_name,
grantee.display_name)
def test_from_headers_x_amz_acl_invalid(self):
with self.assertRaises(InvalidArgument) as cm:
ACL.from_headers({'x-amz-acl': 'invalid'},
Owner('test:tester', 'test:tester'))
self.assertTrue('argument_name' in cm.exception.info)
self.assertEquals(cm.exception.info['argument_name'], 'x-amz-acl')
self.assertEqual(cm.exception.info['argument_name'], 'x-amz-acl')
self.assertTrue('argument_value' in cm.exception.info)
self.assertEquals(cm.exception.info['argument_value'], 'invalid')
self.assertEqual(cm.exception.info['argument_value'], 'invalid')
def test_canned_acl_grantees(self):
grantee_map = canned_acl_grantees(Owner('test:tester', 'test:tester'))
@ -336,7 +336,7 @@ class TestSwift3Subresource(unittest.TestCase):
'bucket-owner-full-control', 'log-delivery-write']
for canned_acl in canned_acls:
self.assertTrue(canned_acl in grantee_map)
self.assertEquals(len(canned_acls), len(grantee_map)) # sanity
self.assertEqual(len(canned_acls), len(grantee_map)) # sanity
def test_base_grantee(self):
grantee = Grantee()

4
swift3/test/unit/test_utils.py

@ -28,11 +28,11 @@ strs = [
class TestSwift3Utils(unittest.TestCase):
def test_camel_to_snake(self):
for s1, s2 in strs:
self.assertEquals(utils.camel_to_snake(s1), s2)
self.assertEqual(utils.camel_to_snake(s1), s2)
def test_snake_to_camel(self):
for s1, s2 in strs:
self.assertEquals(s1, utils.snake_to_camel(s2))
self.assertEqual(s1, utils.snake_to_camel(s2))
def test_validate_bucket_name(self):
# good cases

4
swift3/test/unit/test_versioning.py

@ -33,7 +33,7 @@ class TestSwift3Versioning(Swift3TestCase):
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(status.split()[0], '200')
self.assertEqual(status.split()[0], '200')
fromstring(body, 'VersioningConfiguration')
def test_object_versioning_PUT(self):
@ -42,7 +42,7 @@ class TestSwift3Versioning(Swift3TestCase):
headers={'Authorization': 'AWS test:tester:hmac',
'Date': self.get_date_header()})
status, headers, body = self.call_swift3(req)
self.assertEquals(self._get_error_code(body), 'NotImplemented')
self.assertEqual(self._get_error_code(body), 'NotImplemented')
def test_bucket_versioning_GET(self):
req = Request.blank('/bucket?versioning',