def test_get_response_nonstreaming_ok(self):
http_response = Response()
http_response.headers = {
'content-type': 'application/xml',
'date': 'Sun, 09 Mar 2014 02:55:43 GMT',
'server': 'AmazonS3',
'transfer-encoding': 'chunked',
'x-amz-id-2': 'AAAAAAAAAAAAAAAAAAA',
'x-amz-request-id': 'XXXXXXXXXXXXXXXX'
}
http_response.raw = six.BytesIO(XMLBODY1)
http_response.status_code = 403
http_response.reason = 'Forbidden'
http_response.request = Request()
session = botocore.session.get_session()
service_model = session.get_service_model('s3')
operation_model = service_model.operation_model('ListObjects')
self.assert_response_with_subset_metadata(
response.get_response(operation_model, http_response)[1], {
'ResponseMetadata': {
'RequestId': 'XXXXXXXXXXXXXXXX',
'HostId': 'AAAAAAAAAAAAAAAAAAA',
'HTTPStatusCode': 403
},
'Error': {
'Message': 'Access Denied',
'Code': 'AccessDenied'
}
})
def test_get_response_streaming_ng(self):
http_response = Response()
http_response.headers = {
'content-type': 'application/xml',
'date': 'Sat, 08 Mar 2014 12:05:44 GMT',
'server': 'AmazonS3',
'transfer-encoding': 'chunked',
'x-amz-id-2': 'AAAAAAAAAAAAAAAAAAA',
'x-amz-request-id': 'XXXXXXXXXXXXXXXX'
}
http_response.raw = six.BytesIO(XMLBODY1)
http_response.status_code = 403
http_response.reason = 'Forbidden'
session = botocore.session.get_session()
s3 = session.get_service('s3')
operation = s3.get_operation('GetObject') # streaming operation
self.assertEqual(
response.get_response(operation.model, http_response)[1], {
'Error': {
'Message': 'Access Denied',
'Code': 'AccessDenied',
},
'ResponseMetadata': {
'HostId': 'AAAAAAAAAAAAAAAAAAA',
'RequestId': 'XXXXXXXXXXXXXXXX',
'HTTPStatusCode': 403
},
})
def test_get_response_nonstreaming_ok(self):
http_response = Response()
http_response.headers = {
'content-type': 'application/xml',
'date': 'Sun, 09 Mar 2014 02:55:43 GMT',
'server': 'AmazonS3',
'transfer-encoding': 'chunked',
'x-amz-id-2': 'AAAAAAAAAAAAAAAAAAA',
'x-amz-request-id': 'XXXXXXXXXXXXXXXX'
}
http_response.raw = six.BytesIO(XMLBODY1)
http_response.status_code = 403
http_response.reason = 'Forbidden'
http_response.request = Request()
session = botocore.session.get_session()
s3 = session.get_service('s3')
operation = s3.get_operation('ListObjects') # non-streaming operation
self.assertEqual(
response.get_response(session, operation, http_response)[1], {
'ResponseMetadata': {},
'Errors': [{
'HostId': 'AAAAAAAAAAAAAAAAAAA',
'Message': 'Access Denied',
'Code': 'AccessDenied',
'RequestId': 'XXXXXXXXXXXXXXXX'
}],
'ResponseMetadata': {},
u'CommonPrefixes': [],
u'Contents': [],
})
def test_get_response_nonstreaming_ok(self):
http_response = Response()
http_response.headers = {
'content-type': 'application/xml',
'date': 'Sun, 09 Mar 2014 02:55:43 GMT',
'server': 'AmazonS3',
'transfer-encoding': 'chunked',
'x-amz-id-2': 'AAAAAAAAAAAAAAAAAAA',
'x-amz-request-id': 'XXXXXXXXXXXXXXXX'}
http_response.raw = six.BytesIO(XMLBODY1)
http_response.status_code = 403
http_response.reason = 'Forbidden'
http_response.request = Request()
session = botocore.session.get_session()
s3 = session.get_service('s3')
operation = s3.get_operation('ListObjects') # non-streaming operation
self.assertEqual(
response.get_response(operation.model, http_response)[1],
{ 'ResponseMetadata': {'RequestId': 'XXXXXXXXXXXXXXXX',
'HostId': 'AAAAAAAAAAAAAAAAAAA',
'HTTPStatusCode': 403},
'Error': {'Message': 'Access Denied',
'Code': 'AccessDenied',}
}
)
def test_head_object(self):
http_response = Mock()
http_response.encoding = 'utf-8'
http_response.headers = CaseInsensitiveDict(
{'Date': 'Thu, 22 Aug 2013 02:11:57 GMT',
'Content-Length': '265',
'x-amz-request-id': '2B74ECB010FF029E',
'ETag': '"40d06eb6194712ac1c915783004ef730"',
'Server': 'AmazonS3',
'content-type': 'binary/octet-stream',
'Content-Type': 'binary/octet-stream',
'accept-ranges': 'bytes',
'Last-Modified': 'Tue, 20 Aug 2013 18:33:25 GMT',
'x-amz-server-side-encryption': 'AES256',
'x-amz-meta-mykey1': 'value1',
'x-amz-meta-mykey2': 'value2',
})
http_response.content = ''
http_response.request.method = 'HEAD'
put_object = self.s3.get_operation('HeadObject')
expected = {"AcceptRanges": "bytes",
"ContentType": "binary/octet-stream",
"LastModified": "Tue, 20 Aug 2013 18:33:25 GMT",
"ContentLength": "265",
"ETag": '"40d06eb6194712ac1c915783004ef730"',
"ServerSideEncryption": "AES256",
"Metadata": {
'mykey1': 'value1',
'mykey2': 'value2',
}}
response_data = get_response(self.session, put_object,
http_response)[1]
self.assertEqual(response_data, expected)
def test_get_response_nonstreaming_ng(self):
http_response = Response()
http_response.headers = {
'content-type': 'application/xml',
'date': 'Sat, 08 Mar 2014 12:05:44 GMT',
'server': 'AmazonS3',
'transfer-encoding': 'chunked',
'x-amz-id-2': 'AAAAAAAAAAAAAAAAAAA',
'x-amz-request-id': 'XXXXXXXXXXXXXXXX'}
http_response.raw = six.BytesIO(XMLBODY2)
http_response.status_code = 200
http_response.reason = 'ok'
http_response.request = Request()
session = botocore.session.get_session()
s3 = session.get_service('s3')
operation = s3.get_operation('ListObjects') # non-streaming operation
self.assertEqual(
response.get_response(session, operation, http_response)[1],
{u'CommonPrefixes': [],
u'Contents': [{u'ETag': '"00000000000000000000000000000000"',
u'Key': 'test.png',
u'LastModified': '2014-03-01T17:06:40.000Z',
u'Owner': {u'DisplayName': 'dummy',
u'ID': 'AAAAAAAAAAAAAAAAAAA'},
u'Size': 6702,
u'StorageClass': 'STANDARD'}],
u'IsTruncated': False,
u'Marker': None,
u'MaxKeys': 1000,
u'Name': 'mybucket',
u'Prefix': None,
'ResponseMetadata': {}}
)
def test_head_object_with_json(self):
http_response = Mock()
http_response.encoding = 'utf-8'
http_response.headers = CaseInsensitiveDict(
{'Date': 'Thu, 22 Aug 2013 02:11:57 GMT',
'Content-Length': '0',
'x-amz-request-id': '2B74ECB010FF029E',
'ETag': '"40d06eb6194712ac1c915783004ef730"',
'Server': 'AmazonS3',
'content-type': 'application/json',
'Content-Type': 'application/json',
'accept-ranges': 'bytes',
'Last-Modified': 'Tue, 20 Aug 2013 18:33:25 GMT',
'x-amz-server-side-encryption': 'AES256'})
http_response.content = ''
put_object = self.s3.get_operation('HeadObject')
expected = {"AcceptRanges": "bytes",
"ContentType": "application/json",
"LastModified": "Tue, 20 Aug 2013 18:33:25 GMT",
"ContentLength": "0",
"ETag": '"40d06eb6194712ac1c915783004ef730"',
"ServerSideEncryption": "AES256"
}
response_data = get_response(self.session, put_object,
http_response)[1]
self.assertEqual(response_data, expected)
def test_head_object(self):
http_response = Mock()
http_response.encoding = 'utf-8'
http_response.headers = {
'Date': 'Thu, 22 Aug 2013 02:11:57 GMT',
'Content-Length': '265',
'x-amz-request-id': '2B74ECB010FF029E',
'ETag': '"40d06eb6194712ac1c915783004ef730"',
'Server': 'AmazonS3',
'content-type': 'binary/octet-stream',
'Content-Type': 'binary/octet-stream',
'accept-ranges': 'bytes',
'Last-Modified': 'Tue, 20 Aug 2013 18:33:25 GMT',
'x-amz-server-side-encryption': 'AES256'
}
http_response.content = ''
put_object = self.s3.get_operation('HeadObject')
expected = {
"AcceptRanges": "bytes",
"ContentType": "binary/octet-stream",
"LastModified": "Tue, 20 Aug 2013 18:33:25 GMT",
"ContentLength": "265",
"ETag": '"40d06eb6194712ac1c915783004ef730"',
"ServerSideEncryption": "AES256"
}
response_data = get_response(self.session, put_object,
http_response)[1]
self.assertEqual(response_data, expected)
def test_get_response_nonstreaming_ng(self):
headers = {
'content-type': 'application/xml',
'date': 'Sat, 08 Mar 2014 12:05:44 GMT',
'server': 'AmazonS3',
'transfer-encoding': 'chunked',
'x-amz-id-2': 'AAAAAAAAAAAAAAAAAAA',
'x-amz-request-id': 'XXXXXXXXXXXXXXXX'}
raw = FakeRawResponse(XMLBODY2)
http_response = AWSResponse(None, 200, headers, raw)
session = botocore.session.get_session()
service_model = session.get_service_model('s3')
operation_model = service_model.operation_model('ListObjects')
self.assert_response_with_subset_metadata(
response.get_response(operation_model, http_response)[1],
{u'Contents': [{u'ETag': '"00000000000000000000000000000000"',
u'Key': 'test.png',
u'LastModified': datetime.datetime(2014, 3, 1, 17, 6, 40, tzinfo=tzutc()),
u'Owner': {u'DisplayName': 'dummy',
u'ID': 'AAAAAAAAAAAAAAAAAAA'},
u'Size': 6702,
u'StorageClass': 'STANDARD'}],
u'IsTruncated': False,
u'Marker': "",
u'MaxKeys': 1000,
u'Name': 'mybucket',
u'Prefix': "",
'ResponseMetadata': {
'RequestId': 'XXXXXXXXXXXXXXXX',
'HostId': 'AAAAAAAAAAAAAAAAAAA',
'HTTPStatusCode': 200,
}}
)
def test_get_response_streaming_ng(self):
headers = {
'content-type': 'application/xml',
'date': 'Sat, 08 Mar 2014 12:05:44 GMT',
'server': 'AmazonS3',
'transfer-encoding': 'chunked',
'x-amz-id-2': 'AAAAAAAAAAAAAAAAAAA',
'x-amz-request-id': 'XXXXXXXXXXXXXXXX'
}
raw = FakeRawResponse(XMLBODY1)
http_response = AWSResponse(None, 403, headers, raw)
session = botocore.session.get_session()
service_model = session.get_service_model('s3')
operation_model = service_model.operation_model('GetObject')
self.assert_response_with_subset_metadata(
response.get_response(operation_model, http_response)[1], {
'Error': {
'Message': 'Access Denied',
'Code': 'AccessDenied'
},
'ResponseMetadata': {
'HostId': 'AAAAAAAAAAAAAAAAAAA',
'RequestId': 'XXXXXXXXXXXXXXXX',
'HTTPStatusCode': 403
},
})
def test_get_response_streaming_ng(self):
http_response = Response()
http_response.headers = {
'content-type': 'application/xml',
'date': 'Sat, 08 Mar 2014 12:05:44 GMT',
'server': 'AmazonS3',
'transfer-encoding': 'chunked',
'x-amz-id-2': 'AAAAAAAAAAAAAAAAAAA',
'x-amz-request-id': 'XXXXXXXXXXXXXXXX'}
http_response.raw = six.BytesIO(XMLBODY1)
http_response.status_code = 403
http_response.reason = 'Forbidden'
session = botocore.session.get_session()
service_model = session.get_service_model('s3')
operation_model = service_model.operation_model('GetObject')
self.assertEqual(
response.get_response(operation_model, http_response)[1],
{'Error': {'Message': 'Access Denied',
'Code': 'AccessDenied',},
'ResponseMetadata': {'HostId': 'AAAAAAAAAAAAAAAAAAA',
'RequestId': 'XXXXXXXXXXXXXXXX',
'HTTPStatusCode': 403},
}
)
def test_get_response_streaming_ng(self):
http_response = Response()
http_response.headers = {
'content-type': 'application/xml',
'date': 'Sat, 08 Mar 2014 12:05:44 GMT',
'server': 'AmazonS3',
'transfer-encoding': 'chunked',
'x-amz-id-2': 'AAAAAAAAAAAAAAAAAAA',
'x-amz-request-id': 'XXXXXXXXXXXXXXXX'}
http_response.raw = six.BytesIO(XMLBODY1)
http_response.status_code = 403
http_response.reason = 'Forbidden'
session = botocore.session.get_session()
s3 = session.get_service('s3')
operation = s3.get_operation('GetObject') # streaming operation
self.assertEqual(
response.get_response(session, operation, http_response)[1],
{u'Body': None,
'Errors': [{'HostId': 'AAAAAAAAAAAAAAAAAAA',
'Message': 'Access Denied',
'Code': 'AccessDenied',
'RequestId': 'XXXXXXXXXXXXXXXX'}],
'ResponseMetadata': {},
u'Metadata': {}}
)
def test_get_response_nonstreaming_ok(self):
headers = {
'content-type': 'application/xml',
'date': 'Sun, 09 Mar 2014 02:55:43 GMT',
'server': 'AmazonS3',
'transfer-encoding': 'chunked',
'x-amz-id-2': 'AAAAAAAAAAAAAAAAAAA',
'x-amz-request-id': 'XXXXXXXXXXXXXXXX'}
raw = FakeRawResponse(XMLBODY1)
http_response = AWSResponse(None, 403, headers, raw)
session = botocore.session.get_session()
service_model = session.get_service_model('s3')
operation_model = service_model.operation_model('ListObjects')
self.assert_response_with_subset_metadata(
response.get_response(operation_model, http_response)[1],
{
'ResponseMetadata': {
'RequestId': 'XXXXXXXXXXXXXXXX',
'HostId': 'AAAAAAAAAAAAAAAAAAA',
'HTTPStatusCode': 403
},
'Error': {
'Message': 'Access Denied',
'Code': 'AccessDenied'
}
})
def test_list_objects_with_invalid_content_length(self):
http_response = Mock()
http_response.encoding = 'utf-8'
http_response.headers = CaseInsensitiveDict(
{'Date': 'Thu, 22 Aug 2013 02:11:57 GMT',
# We say we have 265 bytes but we're returning 0,
# this should raise an exception because this is not
# a HEAD request.
'Content-Length': '265',
'x-amz-request-id': '2B74ECB010FF029E',
'ETag': '"40d06eb6194712ac1c915783004ef730"',
'Server': 'AmazonS3',
'content-type': 'binary/octet-stream',
'Content-Type': 'binary/octet-stream',
'accept-ranges': 'bytes',
'Last-Modified': 'Tue, 20 Aug 2013 18:33:25 GMT',
'x-amz-server-side-encryption': 'AES256'
})
http_response.content = ''
http_response.request.method = 'GET'
list_objects = self.s3.get_operation('ListObjects')
expected = {"AcceptRanges": "bytes",
"ContentType": "binary/octet-stream",
"LastModified": "Tue, 20 Aug 2013 18:33:25 GMT",
"ContentLength": "265",
"ETag": '"40d06eb6194712ac1c915783004ef730"',
"ServerSideEncryption": "AES256"
}
with self.assertRaises(IncompleteReadError):
response_data = get_response(self.session, list_objects,
http_response)[1]
def test_get_response_nonstreaming_ng(self):
http_response = Response()
http_response.headers = {
'content-type': 'application/xml',
'date': 'Sat, 08 Mar 2014 12:05:44 GMT',
'server': 'AmazonS3',
'transfer-encoding': 'chunked',
'x-amz-id-2': 'AAAAAAAAAAAAAAAAAAA',
'x-amz-request-id': 'XXXXXXXXXXXXXXXX'
}
http_response.raw = six.BytesIO(XMLBODY2)
http_response.status_code = 200
http_response.reason = 'ok'
http_response.request = Request()
session = botocore.session.get_session()
s3 = session.get_service('s3')
operation = s3.get_operation('ListObjects') # non-streaming operation
self.assertEqual(
response.get_response(operation.model, http_response)[1], {
u'Contents': [{
u'ETag':
'"00000000000000000000000000000000"',
u'Key':
'test.png',
u'LastModified':
datetime.datetime(2014, 3, 1, 17, 6, 40, tzinfo=tzutc()),
u'Owner': {
u'DisplayName': 'dummy',
u'ID': 'AAAAAAAAAAAAAAAAAAA'
},
u'Size':
6702,
u'StorageClass':
'STANDARD'
}],
u'IsTruncated':
False,
u'Marker':
"",
u'MaxKeys':
1000,
u'Name':
'mybucket',
u'Prefix':
"",
'ResponseMetadata': {
'RequestId': 'XXXXXXXXXXXXXXXX',
'HostId': 'AAAAAAAAAAAAAAAAAAA',
'HTTPStatusCode': 200,
}
})
def test_get_response_nonstreaming_ng(self):
headers = {
'content-type': 'application/xml',
'date': 'Sat, 08 Mar 2014 12:05:44 GMT',
'server': 'AmazonS3',
'transfer-encoding': 'chunked',
'x-amz-id-2': 'AAAAAAAAAAAAAAAAAAA',
'x-amz-request-id': 'XXXXXXXXXXXXXXXX'
}
raw = FakeRawResponse(XMLBODY2)
http_response = AWSResponse(None, 200, headers, raw)
session = botocore.session.get_session()
service_model = session.get_service_model('s3')
operation_model = service_model.operation_model('ListObjects')
self.assert_response_with_subset_metadata(
response.get_response(operation_model, http_response)[1], {
u'Contents': [{
u'ETag':
'"00000000000000000000000000000000"',
u'Key':
'test.png',
u'LastModified':
datetime.datetime(2014, 3, 1, 17, 6, 40, tzinfo=tzutc()),
u'Owner': {
u'DisplayName': 'dummy',
u'ID': 'AAAAAAAAAAAAAAAAAAA'
},
u'Size':
6702,
u'StorageClass':
'STANDARD'
}],
u'IsTruncated':
False,
u'Marker':
"",
u'MaxKeys':
1000,
u'Name':
'mybucket',
u'Prefix':
"",
'ResponseMetadata': {
'RequestId': 'XXXXXXXXXXXXXXXX',
'HostId': 'AAAAAAAAAAAAAAAAAAA',
'HTTPStatusCode': 200,
}
})
def test_put_object(self):
http_response = Mock()
http_response.encoding = 'utf-8'
http_response.headers = {'Date': 'Thu, 22 Aug 2013 02:11:57 GMT',
'Content-Length': '0',
'x-amz-request-id': '2B74ECB010FF029E',
'ETag': '"b081e66e7e0c314285c655cafb4d1e71"',
'x-amz-id-2': 'bKECRRBFttBRVbJPIVBLQwwipI0i+s9HMvNFdttR17ouR0pvQSKEJUR+1c6cW1nQ',
'Server': 'AmazonS3',
'content-type': 'text/xml'}
http_response.content = ''
put_object = self.s3.get_operation('PutObject')
expected = {"ETag": '"b081e66e7e0c314285c655cafb4d1e71"'}
response_data = get_response(self.session, put_object, http_response)[1]
self.assertEqual(response_data, expected)
def test_put_object(self):
http_response = Mock()
http_response.encoding = 'utf-8'
http_response.headers = {
'Date': 'Thu, 22 Aug 2013 02:11:57 GMT',
'Content-Length': '0',
'x-amz-request-id': '2B74ECB010FF029E',
'ETag': '"b081e66e7e0c314285c655cafb4d1e71"',
'x-amz-id-2':
'bKECRRBFttBRVbJPIVBLQwwipI0i+s9HMvNFdttR17ouR0pvQSKEJUR+1c6cW1nQ',
'Server': 'AmazonS3',
'content-type': 'text/xml'
}
http_response.content = ''
put_object = self.s3.get_operation('PutObject')
expected = {"ETag": '"b081e66e7e0c314285c655cafb4d1e71"'}
response_data = get_response(self.session, put_object,
http_response)[1]
self.assertEqual(response_data, expected)
def test_get_response_streaming_ok(self):
headers = {
'content-type': 'image/png',
'server': 'AmazonS3',
'AcceptRanges': 'bytes',
'transfer-encoding': 'chunked',
'ETag': '"00000000000000000000000000000000"',
}
raw = FakeRawResponse(b'\x89PNG\r\n\x1a\n\x00\x00')
http_response = AWSResponse(None, 200, headers, raw)
session = botocore.session.get_session()
service_model = session.get_service_model('s3')
operation_model = service_model.operation_model('GetObject')
res = response.get_response(operation_model, http_response)
self.assertTrue(isinstance(res[1]['Body'], response.StreamingBody))
self.assertEqual(res[1]['ETag'], '"00000000000000000000000000000000"')
def test_list_objects_with_invalid_content_length(self):
http_response = Mock()
http_response.encoding = 'utf-8'
http_response.headers = CaseInsensitiveDict({
'Date':
'Thu, 22 Aug 2013 02:11:57 GMT',
# We say we have 265 bytes but we're returning 0,
# this should raise an exception because this is not
# a HEAD request.
'Content-Length':
'265',
'x-amz-request-id':
'2B74ECB010FF029E',
'ETag':
'"40d06eb6194712ac1c915783004ef730"',
'Server':
'AmazonS3',
'content-type':
'binary/octet-stream',
'Content-Type':
'binary/octet-stream',
'accept-ranges':
'bytes',
'Last-Modified':
'Tue, 20 Aug 2013 18:33:25 GMT',
'x-amz-server-side-encryption':
'AES256'
})
http_response.content = ''
http_response.request.method = 'GET'
list_objects = self.s3.get_operation('ListObjects')
expected = {
"AcceptRanges": "bytes",
"ContentType": "binary/octet-stream",
"LastModified": "Tue, 20 Aug 2013 18:33:25 GMT",
"ContentLength": "265",
"ETag": '"40d06eb6194712ac1c915783004ef730"',
"ServerSideEncryption": "AES256"
}
with self.assertRaises(IncompleteReadError):
response_data = get_response(self.session, list_objects,
http_response)[1]
def test_get_response_streaming_ok(self):
headers = {
'content-type': 'image/png',
'server': 'AmazonS3',
'AcceptRanges': 'bytes',
'transfer-encoding': 'chunked',
'ETag': '"00000000000000000000000000000000"',
}
raw = FakeRawResponse(b'\x89PNG\r\n\x1a\n\x00\x00')
http_response = AWSResponse(None, 200, headers, raw)
session = botocore.session.get_session()
service_model = session.get_service_model('s3')
operation_model = service_model.operation_model('GetObject')
res = response.get_response(operation_model, http_response)
self.assertTrue(isinstance(res[1]['Body'], response.StreamingBody))
self.assertEqual(res[1]['ETag'],
'"00000000000000000000000000000000"')
def test_get_response_streaming_ok(self):
http_response = Response()
http_response.headers = {
'content-type': 'image/png',
'server': 'AmazonS3',
'AcceptRanges': 'bytes',
'transfer-encoding': 'chunked',
'ETag': '"00000000000000000000000000000000"',
}
http_response.raw = six.BytesIO(b'\x89PNG\r\n\x1a\n\x00\x00')
http_response.status_code = 200
http_response.reason = 'OK'
session = botocore.session.get_session()
s3 = session.get_service('s3')
operation = s3.get_operation('GetObject')
res = response.get_response(operation.model, http_response)
self.assertTrue(isinstance(res[1]['Body'], response.StreamingBody))
self.assertEqual(res[1]['ETag'], '"00000000000000000000000000000000"')
def test_get_response_streaming_ok(self):
http_response = Response()
http_response.headers = {
'content-type': 'image/png',
'server': 'AmazonS3',
'AcceptRanges': 'bytes',
'transfer-encoding': 'chunked',
'ETag': '"00000000000000000000000000000000"',
}
http_response.raw = six.BytesIO(b'\x89PNG\r\n\x1a\n\x00\x00')
http_response.status_code = 200
http_response.reason = 'OK'
session = botocore.session.get_session()
s3 = session.get_service('s3')
operation = s3.get_operation('GetObject')
res = response.get_response(operation.model, http_response)
self.assertTrue(isinstance(res[1]['Body'], response.StreamingBody))
self.assertEqual(res[1]['ETag'],
'"00000000000000000000000000000000"')
