def test_200_get_swagger_spec():
response_adapter_instance = Mock(spec=IncomingResponse, status_code=200)
response_adapter_type = Mock(return_value=response_adapter_instance)
http_future = HttpFuture(future=Mock(spec=FutureAdapter),
response_adapter=response_adapter_type)
assert response_adapter_instance == http_future.result()
def test_200_get_swagger_spec(mock_future_adapter):
response_adapter_instance = Mock(spec=IncomingResponse, status_code=200)
response_adapter_type = Mock(return_value=response_adapter_instance)
http_future = HttpFuture(
future=mock_future_adapter,
response_adapter=response_adapter_type)
assert response_adapter_instance == http_future.result()
def test_200_get_swagger_spec(mock_future_adapter):
response_adapter_instance = Mock(spec=IncomingResponse, status_code=200)
response_adapter_type = Mock(return_value=response_adapter_instance)
http_future = HttpFuture(
future=mock_future_adapter,
response_adapter=response_adapter_type,
) # type: HttpFuture[None]
assert response_adapter_instance == http_future.result()
def test_cancel_is_backwards_compatible(mock_log):
future_adapter = MyFutureAdapter()
future = HttpFuture(
future=future_adapter,
response_adapter=IncomingResponse(),
) # type: HttpFuture[None]
future.cancel()
assert mock_log.warning.call_count == 1
def test_cancel():
mock_future_adapter = mock.Mock()
future = HttpFuture(
future=mock_future_adapter,
response_adapter=IncomingResponse(),
) # type: HttpFuture[None]
future.cancel()
assert mock_future_adapter.cancel.call_count == 1
def test_200_no_response_callback():
# This use case is for http requests that are made outside of the
# swagger spec e.g. retrieving the swagger schema
response_adapter_instance = Mock(spec=IncomingResponse, status_code=200)
response_adapter_type = Mock(return_value=response_adapter_instance)
http_future = HttpFuture(future=Mock(spec=Future),
response_adapter=response_adapter_type,
callback=None)
assert response_adapter_instance == http_future.result()
def test_200_with_response_callback():
response_callback = Mock(return_value='hello world')
response_adapter_instance = Mock(spec=IncomingResponse, status_code=200)
response_adapter_type = Mock(return_value=response_adapter_instance)
http_future = HttpFuture(future=Mock(spec=Future),
response_adapter=response_adapter_type,
callback=response_callback)
assert 'hello world' == http_future.result()
def test_200_success():
response_callback = Mock(return_value='hello world')
response_adapter_instance = Mock(spec=ResponseLike, status_code=200)
response_adapter_type = Mock(return_value=response_adapter_instance)
http_future = HttpFuture(
future=Mock(spec=Future),
response_adapter=response_adapter_type,
callback=response_callback)
assert 'hello world' == http_future.result()
def test_no_response_callback():
# This use case is for http requests that are made outside of the
# swagger spec e.g. retrieving the swagger schema
response_adapter_instance = Mock(spec=ResponseLike)
response_adapter_type = Mock(return_value=response_adapter_instance)
http_future = HttpFuture(
future=Mock(spec=Future),
response_adapter=response_adapter_type,
callback=None)
assert response_adapter_instance == http_future.result()
def test_4XX_5XX_failure(_):
response_callback = Mock(return_value='hello world')
response_adapter_instance = Mock(spec=ResponseLike, status_code=400)
response_adapter_type = Mock(return_value=response_adapter_instance)
http_future = HttpFuture(
future=Mock(spec=Future),
response_adapter=response_adapter_type,
callback=response_callback)
with pytest.raises(HTTPError):
http_future.result()
def test_non_2XX_with_response_callback():
response_adapter_instance = Mock(spec=IncomingResponse, status_code=400)
response_callback = Mock(side_effect=HTTPError(response_adapter_instance))
response_adapter_type = Mock(return_value=response_adapter_instance)
http_future = HttpFuture(future=Mock(spec=Future),
response_adapter=response_adapter_type,
callback=response_callback)
with pytest.raises(HTTPError) as excinfo:
http_future.result()
assert excinfo.value.response.status_code == 400
def test_200_service_call(_):
response_adapter_instance = Mock(spec=IncomingResponse,
status_code=200,
swagger_result='hello world')
response_adapter_type = Mock(return_value=response_adapter_instance)
http_future = HttpFuture(future=Mock(spec=FutureAdapter),
response_adapter=response_adapter_type,
operation=Mock(spec=Operation))
assert 'hello world' == http_future.result()
def test_non_2XX_with_response_callback():
response_adapter_instance = Mock(spec=IncomingResponse, status_code=400)
response_callback = Mock(side_effect=HTTPError(response_adapter_instance))
response_adapter_type = Mock(return_value=response_adapter_instance)
http_future = HttpFuture(
future=Mock(spec=Future),
response_adapter=response_adapter_type,
callback=response_callback)
with pytest.raises(HTTPError) as excinfo:
http_future.result()
assert excinfo.value.response.status_code == 400
def test_400_service_call(mock_unmarshal_response):
response_adapter_instance = Mock(spec=IncomingResponse,
status_code=400,
swagger_result={'error': 'Blah'})
mock_unmarshal_response.side_effect = HTTPError(response_adapter_instance)
response_adapter_type = Mock(return_value=response_adapter_instance)
http_future = HttpFuture(future=Mock(spec=FutureAdapter),
response_adapter=response_adapter_type,
operation=Mock(spec=Operation))
with pytest.raises(HTTPError) as excinfo:
http_future.result()
assert excinfo.value.response.status_code == 400
def test_200_service_call(_, mock_future_adapter):
response_adapter_instance = Mock(
spec=IncomingResponse,
status_code=200,
swagger_result='hello world')
response_adapter_type = Mock(return_value=response_adapter_instance)
http_future = HttpFuture(
future=mock_future_adapter,
response_adapter=response_adapter_type,
operation=Mock(spec=Operation))
assert 'hello world' == http_future.result()
def test_400_service_call(mock_unmarshal_response, mock_future_adapter):
response_adapter_instance = Mock(
spec=IncomingResponse,
status_code=400,
swagger_result={'error': 'Blah'})
mock_unmarshal_response.side_effect = HTTPError(response_adapter_instance)
response_adapter_type = Mock(return_value=response_adapter_instance)
http_future = HttpFuture(
future=mock_future_adapter,
response_adapter=response_adapter_type,
operation=Mock(spec=Operation))
with pytest.raises(HTTPError) as excinfo:
http_future.result()
assert excinfo.value.response.status_code == 400
def request(self, request_params, operation=None, request_config=None):
request_for_twisted = self.prepare_request_for_twisted(request_params)
request_for_twisted["headers"].update(self.headers)
future_adapter = self.future_adapter_class(
fido.fetch(**request_for_twisted))
return HttpFuture(future_adapter, self.response_adapter_class,
operation, request_config)
def request(self, request_params, response_callback=None):
"""Sets up the request params as per Twisted Agent needs.
Sets up crochet and triggers the API request in background
:param request_params: request parameters for API call
:type request_params: dict
:param response_callback: Function to be called after
receiving the response
:type response_callback: method
:rtype: :class: `bravado_core.http_future.HttpFuture`
"""
url = '%s?%s' % (request_params['url'],
urllib_utf8.urlencode(
request_params.get('params', []), True))
fetch_kwargs = {
'method': str(request_params.get('method', 'GET')),
'body': stringify_body(request_params),
'headers': request_params.get('headers', {}),
}
for fetch_kwarg in ('connect_timeout', 'timeout'):
if fetch_kwarg in request_params:
fetch_kwargs[fetch_kwarg] = request_params[fetch_kwarg]
concurrent_future = fido.fetch(url, **fetch_kwargs)
return HttpFuture(concurrent_future, FidoResponseAdapter,
response_callback)
def http_future(mock_future_adapter, mock_operation, mock_incoming_response):
response_adapter_type = mock.Mock(return_value=mock_incoming_response)
return HttpFuture(
future=mock_future_adapter,
response_adapter=response_adapter_type,
operation=mock_operation,
)
def request(
self,
request_params, # type: typing.MutableMapping[str, typing.Any]
operation=None, # type: typing.Optional[Operation]
request_config=None, # type: typing.Optional[RequestConfig]
):
# type: (...) -> HttpFuture[T]
"""Sets up the request params as per Twisted Agent needs.
Sets up crochet and triggers the API request in background
:param request_params: request parameters for the http request.
:type request_params: dict
:param operation: operation that this http request is for. Defaults
to None - in which case, we're obviously just retrieving a Swagger
Spec.
:type operation: :class:`bravado_core.operation.Operation`
:param RequestConfig request_config: per-request configuration
:rtype: :class: `bravado_core.http_future.HttpFuture`
"""
request_for_twisted = self.prepare_request_for_twisted(request_params)
future_adapter = self.future_adapter_class(fido.fetch(**request_for_twisted)) # type: FidoFutureAdapter[T]
return HttpFuture(future_adapter,
self.response_adapter_class,
operation,
request_config)
def request(self,
request_params,
operation=None,
response_callbacks=None,
also_return_response=False):
"""
:param request_params: complete request data.
:type request_params: dict
:param operation: operation that this http request is for. Defaults
to None - in which case, we're obviously just retrieving a Swagger
Spec.
:type operation: :class:`bravado_core.operation.Operation`
:param response_callbacks: List of callables to post-process the
incoming response. Expects args incoming_response and operation.
:param also_return_response: Consult the constructor documentation for
:class:`bravado.http_future.HttpFuture`.
:returns: HTTP Future object
:rtype: :class: `bravado_core.http_future.HttpFuture`
"""
sanitized_params, misc_options = self.separate_params(request_params)
requests_future = RequestsFutureAdapter(
self.session,
self.authenticated_request(sanitized_params),
misc_options,
)
return HttpFuture(
requests_future,
RequestsResponseAdapter,
operation,
response_callbacks,
also_return_response,
)
def request(
self,
request_params, # type: typing.MutableMapping[str, typing.Any]
operation=None, # type: typing.Optional[Operation]
request_config=None, # type: typing.Optional[RequestConfig]
):
# type: (...) -> HttpFuture[T]
"""
:param request_params: complete request data.
:type request_params: dict
:param operation: operation that this http request is for. Defaults
to None - in which case, we're obviously just retrieving a Swagger
Spec.
:type operation: :class:`bravado_core.operation.Operation`
:param RequestConfig request_config: per-request configuration
:returns: HTTP Future object
:rtype: :class: `bravado_core.http_future.HttpFuture`
"""
sanitized_params, misc_options = self.separate_params(request_params)
requests_future = RequestsFutureAdapter(
self.session,
self.authenticated_request(sanitized_params),
misc_options,
)
return HttpFuture(
requests_future,
RequestsResponseAdapter,
operation,
request_config,
)
def request(self,
request_params,
operation=None,
response_callbacks=None,
also_return_response=False):
"""Sets up the request params as per Twisted Agent needs.
Sets up crochet and triggers the API request in background
:param request_params: request parameters for the http request.
:type request_params: dict
:param operation: operation that this http request is for. Defaults
to None - in which case, we're obviously just retrieving a Swagger
Spec.
:type operation: :class:`bravado_core.operation.Operation`
:param response_callbacks: List of callables to post-process the
incoming response. Expects args incoming_response and operation.
:param also_return_response: Consult the constructor documentation for
:class:`bravado.http_future.HttpFuture`.
:rtype: :class: `bravado_core.http_future.HttpFuture`
"""
request_for_twisted = self.prepare_request_for_twisted(request_params)
future_adapter = FidoFutureAdapter(fido.fetch(**request_for_twisted))
return HttpFuture(future_adapter, FidoResponseAdapter, operation,
response_callbacks, also_return_response)
def test_also_return_response_true(_):
# Verify HTTPFuture(..., also_return_response=True).result()
# returns the (swagger_result, http_response) and not just swagger_result
response_adapter_instance = Mock(spec=IncomingResponse,
status_code=200,
swagger_result='hello world')
response_adapter_type = Mock(return_value=response_adapter_instance)
http_future = HttpFuture(future=Mock(spec=FutureAdapter),
response_adapter=response_adapter_type,
operation=Mock(spec=Operation),
also_return_response=True)
swagger_result, http_response = http_future.result()
assert http_response == response_adapter_instance
assert swagger_result == 'hello world'
def handle_future(self,
bravado_fut: HttpFuture,
include_meta: bool = False):
resp: BravadoResponse = bravado_fut.response()
if include_meta:
return resp.result, resp.metadata
else:
return resp.result
def test_200_with_response_callback():
def response_callback(incoming_response):
incoming_response.swagger_result = 'hello world'
response_adapter_instance = Mock(
spec=IncomingResponse,
status_code=200)
response_adapter_type = Mock(return_value=response_adapter_instance)
http_future = HttpFuture(
future=Mock(spec=Future),
response_adapter=response_adapter_type,
callback=response_callback)
assert 'hello world' == http_future.result()
def test_500_get_swagger_spec():
response_adapter_instance = Mock(spec=IncomingResponse, status_code=500)
response_adapter_type = Mock(return_value=response_adapter_instance)
with pytest.raises(HTTPError) as excinfo:
HttpFuture(future=Mock(spec=FutureAdapter),
response_adapter=response_adapter_type).result()
assert excinfo.value.response.status_code == 500
def test_also_return_response_true(_, mock_future_adapter):
# Verify HTTPFuture(..., also_return_response=True).result()
# returns the (swagger_result, http_response) and not just swagger_result
response_adapter_instance = Mock(
spec=IncomingResponse,
status_code=200,
swagger_result='hello world')
response_adapter_type = Mock(return_value=response_adapter_instance)
http_future = HttpFuture(
future=mock_future_adapter,
response_adapter=response_adapter_type,
operation=Mock(spec=Operation),
request_config=RequestConfig({}, also_return_response_default=True))
swagger_result, http_response = http_future.result()
assert http_response == response_adapter_instance
assert swagger_result == 'hello world'
def test_also_return_response_true(_):
# Verify HTTPFuture(..., also_return_response=True).result()
# returns the (swagger_result, http_response) and not just swagger_result
response_adapter_instance = Mock(
spec=IncomingResponse,
status_code=200,
swagger_result='hello world')
response_adapter_type = Mock(return_value=response_adapter_instance)
http_future = HttpFuture(
concurrent_future=Mock(spec=Future),
response_adapter=response_adapter_type,
operation=Mock(spec=Operation),
also_return_response=True)
swagger_result, http_response = http_future.result()
assert http_response == response_adapter_instance
assert swagger_result == 'hello world'
def test_also_return_response_true():
# Verify HTTPFuture(..., also_return_response=True).result()
# returns the (swagger_result, http_response) and not just swagger_result
def response_callback(incoming_response):
incoming_response.swagger_result = 'hello world'
response_adapter_instance = Mock(spec=IncomingResponse, status_code=200)
response_adapter_type = Mock(return_value=response_adapter_instance)
http_future = HttpFuture(
future=Mock(spec=Future),
response_adapter=response_adapter_type,
callback=response_callback,
also_return_response=True)
swagger_result, http_response = http_future.result()
assert http_response == response_adapter_instance
assert swagger_result == 'hello world'
def test_non_2XX_no_response_callback():
response_adapter_instance = Mock(spec=IncomingResponse, status_code=500)
response_adapter_type = Mock(return_value=response_adapter_instance)
with pytest.raises(HTTPError) as excinfo:
HttpFuture(future=Mock(spec=Future),
response_adapter=response_adapter_type,
callback=None).result()
assert excinfo.value.response.status_code == 500
def test_also_return_response_true(_, mock_future_adapter):
# Verify HTTPFuture(..., also_return_response=True).result()
# returns the (swagger_result, http_response) and not just swagger_result
response_adapter_instance = Mock(spec=IncomingResponse,
status_code=200,
swagger_result='hello world')
response_adapter_type = Mock(return_value=response_adapter_instance)
http_future = HttpFuture(
future=mock_future_adapter,
response_adapter=response_adapter_type,
operation=Mock(spec=Operation),
request_config=RequestConfig({}, also_return_response_default=True),
) # type: HttpFuture[typing.Tuple[str, IncomingResponse]]
swagger_result, http_response = http_future.result()
assert http_response == response_adapter_instance
assert swagger_result == 'hello world'
def _execute(self, call: HttpFuture, silent=False, remainingRetries=0):
if not silent:
self.logger.info("executing %s %s" % (str(call.operation.http_method).upper(), call.operation.path_name))
# TODO: handle exception
result = call.response().result
if 'result' in result.keys() and result['result'] is not None:
return result['result']
else:
if remainingRetries > 0:
self.logger.debug('retry after empty result for %s: %s' % (call.operation.operation_id, str(result)))
return self._execute(call, silent, remainingRetries - 1)
else:
self.logger.error('got empty result for %s: %s' % (call.operation.operation_id, str(result)))
return None
def _execute(self, call: HttpFuture, silent=False, remainingRetries=0):
# TODO: handle exception
result = call.response().result
if 'result' in result.keys() and result['result'] is not None:
return result['result']
else:
if remainingRetries > 0:
self.logger.debug('retry after empty result for %s: %s' % (call.operation.operation_id, str(result)))
return self._execute(call, silent, remainingRetries - 1)
else:
if self.on_api_error is not None:
msg = "unkown error"
if 'ret_msg' in result.keys():
msg = result['ret_msg']
self.on_api_error("problem sending request: %s %s: %s" %
(str(call.operation.http_method).upper(), call.operation.path_name, msg))
self.logger.error('got empty result for %s, \nparams:%s\nresult: %s' % (call.operation.operation_id, call.future.request.params, str(result)))
return None
def request(self, request_params, response_callback=None):
"""
:param request_params: complete request data.
:type request_params: dict
:param response_callback: Function to be called on the response
:returns: HTTP Future object
:rtype: :class: `bravado_core.http_future.HttpFuture`
"""
sanitized_params, misc_options = self.separate_params(request_params)
requests_future = RequestsFutureAdapter(
self.session, self.authenticated_request(sanitized_params),
misc_options)
return HttpFuture(
requests_future,
RequestsResponseAdapter,
response_callback,
)
def request(self, request_params, operation=None, response_callbacks=None,
also_return_response=False):
"""Sets up the request params as per Twisted Agent needs.
Sets up crochet and triggers the API request in background
:param request_params: request parameters for the http request.
:type request_params: dict
:param operation: operation that this http request is for. Defaults
to None - in which case, we're obviously just retrieving a Swagger
Spec.
:type operation: :class:`bravado_core.operation.Operation`
:param response_callbacks: List of callables to post-process the
incoming response. Expects args incoming_response and operation.
:param also_return_response: Consult the constructor documentation for
:class:`bravado.http_future.HttpFuture`.
:rtype: :class: `bravado_core.http_future.HttpFuture`
"""
url = '%s?%s' % (request_params['url'], urllib_utf8.urlencode(
request_params.get('params', []), True))
fetch_kwargs = {
'method': str(request_params.get('method', 'GET')),
'body': stringify_body(request_params),
'headers': request_params.get('headers', {}),
}
for fetch_kwarg in ('connect_timeout', 'timeout'):
if fetch_kwarg in request_params:
fetch_kwargs[fetch_kwarg] = request_params[fetch_kwarg]
concurrent_future = fido.fetch(url, **fetch_kwargs)
return HttpFuture(concurrent_future,
FidoResponseAdapter,
operation,
response_callbacks,
also_return_response)
def request(self, request_params, operation=None, request_config=None):
"""Sets up the request params as per Twisted Agent needs.
Sets up crochet and triggers the API request in background
:param request_params: request parameters for the http request.
:type request_params: dict
:param operation: operation that this http request is for. Defaults
to None - in which case, we're obviously just retrieving a Swagger
Spec.
:type operation: :class:`bravado_core.operation.Operation`
:param RequestConfig request_config: per-request configuration
:rtype: :class: `bravado_core.http_future.HttpFuture`
"""
request_for_twisted = self.prepare_request_for_twisted(request_params)
future_adapter = FidoFutureAdapter(fido.fetch(**request_for_twisted))
return HttpFuture(future_adapter,
FidoResponseAdapter,
operation,
request_config)
def request(self, request_params, operation=None, request_config=None):
sanitized_params = self.sanitize_params(request_params)
django_test_future = DjangoTestFutureAdapter(self.test_client, sanitized_params)
return HttpFuture(django_test_future, DjangoTestResponseAdapter, operation, request_config)
def _send(self):
return HttpFuture(self.requests_future,
self.requestsresponse_adapter,
operation=self.operation,
request_config=self.request_config).result()
