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_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 add_client_error(self, method, service_error_code='',
service_message='', http_status_code=400,
service_error_meta=None, expected_params=None):
"""
Adds a ``ClientError`` to the response queue.
:param method: The name of the service method to return the error on.
:type method: str
:param service_error_code: The service error code to return,
e.g. ``NoSuchBucket``
:type service_error_code: str
:param service_message: The service message to return, e.g.
'The specified bucket does not exist.'
:type service_message: str
:param http_status_code: The HTTP status code to return, e.g. 404, etc
:type http_status_code: int
:param service_error_meta: Additional keys to be added to the
service Error
:type service_error_meta: dict
:param expected_params: A dictionary of the expected parameters to
be called for the provided service response. The parameters match
the names of keyword arguments passed to that client call. If
any of the parameters differ a ``StubResponseError`` is thrown.
You can use stub.ANY to indicate a particular parameter to ignore
in validation. stub.ANY is only valid for top level params.
"""
http_response = Response()
http_response.status_code = http_status_code
# We don't look to the model to build this because the caller would
# need to know the details of what the HTTP body would need to
# look like.
parsed_response = {
'ResponseMetadata': {'HTTPStatusCode': http_status_code},
'Error': {
'Message': service_message,
'Code': service_error_code
}
}
if service_error_meta is not None:
parsed_response['Error'].update(service_error_meta)
operation_name = self.client.meta.method_to_api_mapping.get(method)
# Note that we do not allow for expected_params while
# adding errors into the queue yet.
response = {
'operation_name': operation_name,
'response': (http_response, parsed_response),
'expected_params': expected_params,
}
self._queue.append(response)
def add_client_error(self, method, service_error_code='',
service_message='', http_status_code=400,
service_error_meta=None, expected_params=None):
"""
Adds a ``ClientError`` to the response queue.
:param method: The name of the service method to return the error on.
:type method: str
:param service_error_code: The service error code to return,
e.g. ``NoSuchBucket``
:type service_error_code: str
:param service_message: The service message to return, e.g.
'The specified bucket does not exist.'
:type service_message: str
:param http_status_code: The HTTP status code to return, e.g. 404, etc
:type http_status_code: int
:param service_error_meta: Additional keys to be added to the
service Error
:type service_error_meta: dict
:param expected_params: A dictionary of the expected parameters to
be called for the provided service response. The parameters match
the names of keyword arguments passed to that client call. If
any of the parameters differ a ``StubResponseError`` is thrown.
You can use stub.ANY to indicate a particular parameter to ignore
in validation.
"""
http_response = Response()
http_response.status_code = http_status_code
# We don't look to the model to build this because the caller would
# need to know the details of what the HTTP body would need to
# look like.
parsed_response = {
'ResponseMetadata': {'HTTPStatusCode': http_status_code},
'Error': {
'Message': service_message,
'Code': service_error_code
}
}
if service_error_meta is not None:
parsed_response['Error'].update(service_error_meta)
operation_name = self.client.meta.method_to_api_mapping.get(method)
# Note that we do not allow for expected_params while
# adding errors into the queue yet.
response = {
'operation_name': operation_name,
'response': (http_response, parsed_response),
'expected_params': expected_params,
}
self._queue.append(response)
def add_client_error(self,
method,
service_error_code='',
service_message='',
http_status_code=400,
service_error_meta=None):
"""
Adds a ``ClientError`` to the response queue.
:param method: The name of the service method to return the error on.
:type method: str
:param service_error_code: The service error code to return,
e.g. ``NoSuchBucket``
:type service_error_code: str
:param service_message: The service message to return, e.g.
'The specified bucket does not exist.'
:type service_message: str
:param http_status_code: The HTTP status code to return, e.g. 404, etc
:type http_status_code: int
:param service_error_meta: Additional keys to be added to the
service Error
:type service_error_meta: dict
"""
http_response = Response()
http_response.status_code = http_status_code
# We don't look to the model to build this because the caller would
# need to know the details of what the HTTP body would need to
# look like.
parsed_response = {
'ResponseMetadata': {
'HTTPStatusCode': http_status_code
},
'Error': {
'Message': service_message,
'Code': service_error_code
}
}
if service_error_meta is not None:
parsed_response['Error'].update(service_error_meta)
operation_name = self.client.meta.method_to_api_mapping.get(method)
# Note that we do not allow for expected_params while
# adding errors into the queue yet.
response = {
'operation_name': operation_name,
'response': (http_response, parsed_response),
'expected_params': None
}
self._queue.append(response)
def build_response(self, request):
status_code = self.resp['status_code']
headers = self.resp['headers']
body = self.resp['body']
response = Response()
response.status_code = status_code
if 'content-type' not in headers:
headers['content-type'] = 'text/xml'
if 'content-length' not in headers:
headers['content-length'] = len(body)
response.raw = HTTPResponse(body=io.BytesIO(body),
headers=headers,
status=status_code,
reason=CODE_TO_REASON[status_code],
preload_content=False,
decode_content=False)
response.reason = response.raw.reason
# From the request
response.url = request.url
response.request = request
response.connection = self
return response
def add_client_error(self, method, service_error_code='',
service_message='', http_status_code=400,
service_error_meta=None):
"""
Adds a ``ClientError`` to the response queue.
:param method: The name of the service method to return the error on.
:type method: str
:param service_error_code: The service error code to return,
e.g. ``NoSuchBucket``
:type service_error_code: str
:param service_message: The service message to return, e.g.
'The specified bucket does not exist.'
:type service_message: str
:param http_status_code: The HTTP status code to return, e.g. 404, etc
:type http_status_code: int
:param service_error_meta: Additional keys to be added to the
service Error
:type service_error_meta: dict
"""
http_response = Response()
http_response.status_code = http_status_code
# We don't look to the model to build this because the caller would
# need to know the details of what the HTTP body would need to
# look like.
parsed_response = {
'ResponseMetadata': {'HTTPStatusCode': http_status_code},
'Error': {
'Message': service_message,
'Code': service_error_code
}
}
if service_error_meta is not None:
parsed_response['Error'].update(service_error_meta)
operation_name = self.client.meta.method_to_api_mapping.get(method)
# Note that we do not allow for expected_params while
# adding errors into the queue yet.
response = {
'operation_name': operation_name,
'response': (http_response, parsed_response),
'expected_params': None
}
self._queue.append(response)
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 build_response(self, request):
status_code = self.resp['status_code']
headers = self.resp['headers']
body = self.resp['body']
response = Response()
response.status_code = status_code
if 'content-type' not in headers:
headers['content-type'] = 'text/xml'
if 'content-length' not in headers:
headers['content-length'] = len(body)
response.raw = HTTPResponse(
body=io.BytesIO(body),
headers=headers,
status=status_code,
reason=CODE_TO_REASON[status_code],
preload_content=False,
decode_content=False
)
response.reason = response.raw.reason
# From the request
response.url = request.url
response.request = request
response.connection = self
return response
def _add_response(self, method, service_response, expected_params):
if not hasattr(self.client, method):
raise ValueError(
"Client %s does not have method: %s"
% (self.client.meta.service_model.service_name, method))
# Create a successful http response
http_response = Response()
http_response.status_code = 200
http_response.reason = 'OK'
operation_name = self.client.meta.method_to_api_mapping.get(method)
self._validate_response(operation_name, service_response)
# Add the service_response to the queue for returning responses
response = {
'operation_name': operation_name,
'response': (http_response, service_response),
'expected_params': expected_params
}
self._queue.append(response)
def _add_response(self, method, service_response, expected_params):
if not hasattr(self.client, method):
raise ValueError(
"Client %s does not have method: %s" %
(self.client.meta.service_model.service_name, method))
# Create a successful http response
http_response = Response()
http_response.status_code = 200
http_response.reason = 'OK'
operation_name = self.client.meta.method_to_api_mapping.get(method)
self._validate_response(operation_name, service_response)
# Add the service_response to the queue for returning responses
response = {
'operation_name': operation_name,
'response': (http_response, service_response),
'expected_params': expected_params
}
self._queue.append(response)
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_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.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_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_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()
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_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()
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_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_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_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()
service_model = session.get_service_model('s3')
operation_model = service_model.operation_model('ListObjects')
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,
}}
)
