def test_with_timeouts(mock_marshal_param, minimal_swagger_spec, getPetById_spec, request_dict, timeout_kv):
request_dict["url"] = "/pet/{petId}"
op = CallableOperation(Operation.from_spec(minimal_swagger_spec, "/pet/{petId}", "get", getPetById_spec))
k, v = timeout_kv
request = construct_request(op, request_options={k: v}, petId=34)
assert request[k] == v
assert mock_marshal_param.call_count == 1
def __call__(self, _token=None, **op_kwargs):
"""Invoke the actual HTTP request and return a future.
:rtype: :class:`bravado.http_future.HTTPFuture`
"""
warn_for_deprecated_op(self.operation)
# Apply request_options defaults
request_options = op_kwargs.pop('_request_options', {})
request_config = RequestConfig(request_options,
also_return_response_default=True)
request_params = construct_request(
self.operation, request_options, **op_kwargs)
# config = self.operation.swagger_spec.config
http_client = self.operation.swagger_spec.http_client
# Per-request config overrides client wide config
# also_return_response = request_options.get(
# 'also_return_response',
# config['also_return_response'])
# Check if we need an authorization token and if so set it up
if self.require_authorization and _token is None:
raise ESIAuthorizationError('Missing required authorization token')
return http_client.request(
request_params,
operation=self.operation,
request_config=request_config,
authorization_token=_token)
def invoke(op, *args, **kwargs):
if op.http_method != 'get':
clickclick.action('Invoking..')
request = construct_request(op, {}, **kwargs)
c = RequestsClient()
future = c.request(request)
future.result()
clickclick.ok()
def test_with_not_string_headers(
minimal_swagger_dict,
getPetById_spec,
request_dict,
swagger_type,
swagger_format,
header_name,
header_value,
):
url = '/pet/{petId}'
parameter = {
'name': header_name,
'in': 'header',
'required': False,
'type': swagger_type,
}
if swagger_format:
parameter['format'] = swagger_format
minimal_swagger_dict['paths'][url]['get']['parameters'].append(parameter)
minimal_swagger_spec = build_swagger_spec(minimal_swagger_dict)
request_dict['url'] = url
operation = Operation.from_spec(
swagger_spec=minimal_swagger_spec,
path_name='/pet/{petId}',
http_method='get',
op_spec=getPetById_spec,
)
petId = 34
api_key = 'foo'
request = construct_request(
operation=operation,
request_options={'headers': {
header_name: header_value
}},
petId=petId,
api_key=api_key,
)
# To unmarshall a request bravado-core needs the request to be wrapped
# by an object with a specific list of attributes
request_object = type(
'IncomingRequest', (IncomingRequest, ), {
'path': {
'petId': petId
},
'query': {},
'form': {},
'headers': request['headers'],
'files': mock.Mock(),
})
assert request['headers'][header_name] == str(header_value)
unmarshalled_request = unmarshal_request(request_object, operation)
assert unmarshalled_request[header_name] == header_value
def test_with_timeouts(mock_marshal_param, minimal_swagger_spec,
getPetById_spec, request_dict, timeout_kv):
request_dict['url'] = '/pet/{petId}'
op = CallableOperation(Operation.from_spec(
minimal_swagger_spec, '/pet/{petId}', 'get', getPetById_spec))
k, v = timeout_kv
request = construct_request(op, request_options={k: v}, petId=34, api_key='foo')
assert request[k] == v
assert mock_marshal_param.call_count == 2
def test_with_timeouts(
mock_marshal_param, minimal_swagger_spec,
getPetById_spec, request_dict, timeout_kv,
):
request_dict['url'] = '/pet/{petId}'
op = CallableOperation(Operation.from_spec(
minimal_swagger_spec, '/pet/{petId}', 'get', getPetById_spec))
k, v = timeout_kv
request = construct_request(op, request_options={k: v}, petId=34, api_key='foo')
assert request[k] == v
assert mock_marshal_param.call_count == 2
def test_with_not_string_headers(
minimal_swagger_dict, getPetById_spec, request_dict,
swagger_type, swagger_format, header_name, header_value,
):
url = '/pet/{petId}'
parameter = {
'name': header_name,
'in': 'header',
'required': False,
'type': swagger_type,
}
if swagger_format:
parameter['format'] = swagger_format
minimal_swagger_dict['paths'][url]['get']['parameters'].append(parameter)
minimal_swagger_spec = build_swagger_spec(minimal_swagger_dict)
request_dict['url'] = url
operation = Operation.from_spec(
swagger_spec=minimal_swagger_spec,
path_name='/pet/{petId}',
http_method='get',
op_spec=getPetById_spec,
)
petId = 34
api_key = 'foo'
request = construct_request(
operation=operation,
request_options={'headers': {header_name: header_value}},
petId=petId,
api_key=api_key,
)
# To unmarshall a request bravado-core needs the request to be wrapped
# by an object with a specific list of attributes
request_object = type('IncomingRequest', (IncomingRequest,), {
'path': {'petId': petId},
'query': {},
'form': {},
'headers': request['headers'],
'files': mock.Mock(),
})
expected_header_value = str(header_value)
# we need to handle a backwards-incompatible change in bravado-core 5.0.5
if swagger_type == 'boolean':
assert request['headers'][header_name] in (expected_header_value, expected_header_value.lower())
else:
assert request['headers'][header_name] == expected_header_value
unmarshalled_request = unmarshal_request(request_object, operation)
assert unmarshalled_request[header_name] == header_value
def test_use_msgpack(
minimal_swagger_spec,
getPetById_spec,
):
op = CallableOperation(
Operation.from_spec(minimal_swagger_spec, '/pet/{petId}', 'get',
getPetById_spec))
request = construct_request(
op,
request_options={
'use_msgpack': True,
},
petId=1,
)
assert request['headers']['Accept'] == 'application/msgpack'
def test_use_msgpack(
minimal_swagger_spec,
getPetById_spec,
):
op = CallableOperation(
Operation.from_spec(
minimal_swagger_spec,
'/pet/{petId}',
'get',
getPetById_spec
)
)
request = construct_request(
op,
request_options={
'use_msgpack': True,
},
petId=1,
)
assert request['headers']['Accept'] == 'application/msgpack'
def test_use_msgpack(
minimal_swagger_spec,
getPetById_spec,
):
op = CallableOperation(
Operation.from_spec(minimal_swagger_spec, '/pet/{petId}', 'get',
getPetById_spec))
request_options = {
'use_msgpack': True,
'headers': {
'Some-Header': 'header-value'
}
} # type: Dict[str, Any]
request = construct_request(
op,
request_options=request_options,
petId=1,
)
assert request['headers']['Accept'] == 'application/msgpack'
assert request['headers']['Some-Header'] == 'header-value', \
"Requested header should be present"
assert 'Accept' not in request_options['headers'], \
"Original request options should not be modified"
def _bravado_construct_request(self):
"""
An example request dict from swagger's pet store application looks like:
{'url': u'http://petstore.swagger.io/v2/pet/42',
'headers': {},
'params': {},
'method': 'DELETE'}
Or also like:
{'url': u'http://petstore.swagger.io/v2/pet/42',
'headers': {u'api_key': 'FrAmE30.'},
'params': {},
'method': 'DELETE'}
:return: The dict
"""
parameters = self._get_filled_parameters()
return construct_request(self.operation,
request_options={},
**parameters)
def ro_opInvokeCapture(roOp, ):
####+END:
pp = pprint.PrettyPrinter(indent=4)
#icm.TM_here("svcSpec={svcSpec} -- perfSap={perfSap}".format(svcSpec=roOp.svcSpec, perfSap=roOp.perfSap))
loadedSvcSpec, origin_url = loadSvcSpec(roOp.svcSpec, roOp.perfSap)
if roOp.perfSap:
#origin_url = "http://localhost:8080"
origin_url = roOp.perfSap
#
# NOTYET LOG level changes here
#
#icm.TM_here("{}".format(pp.pformat(loadedSvcSpec)))
opBravadoObj = getOperationWithResourceAndOpName(
loadedSvcSpec,
origin_url,
roOp.resource,
roOp.opName,
)
if not opBravadoObj:
icm.EH_problem_usageError(
"""getOperationWithResourceAndOpName Failed: resource={resource} opName={opName}"""
.format(
resource=roOp.resource,
opName=roOp.opName,
))
return None
requestOptions = dict()
params = roOp.roParams
headerParams = params.headerParams
if headerParams:
requestOptions["headers"] = headerParams
urlParams = params.urlParams
if urlParams == None:
urlParams = dict()
bodyParams = params.bodyParams
icm.TM_here("{}".format(pp.pformat(bodyParams)))
if bodyParams:
#
# With ** we achieve kwargs
#
# func(**{'type':'Event'}) is equivalent to func(type='Event')
#
request = construct_request(opBravadoObj,
requestOptions,
body=bodyParams,
**urlParams)
else:
request = construct_request(opBravadoObj, requestOptions, **urlParams)
icm.LOG_here("request={request}".format(request=pp.pformat(request)))
c = RequestsClient()
#
# This is where the invoke request goes out
#
future = c.request(request)
#
# This where the invoke response comes in
#
opResults = {}
try:
result = future.result()
except Exception as e:
#icm.EH_critical_exception(e)
opResults = None
roResults = ro.Ro_Results(
httpResultCode=500, # type=int
httpResultText="Internal Server Error", # type=str
opResults=opResults,
opResultHeaders=None,
)
if opResults != None:
#
# result
#
# 2018-10-01 -- https://github.com/Yelp/bravado/blob/master/bravado/requests_client.py
# class RequestsResponseAdapter(IncomingResponse):
#
# type(result._delegate.text) = unicode
# type(result._delegate.content) = str
#
opResults = None
if result._delegate.content:
try:
opResults = result.json()
except Exception as e:
icm.EH_critical_exception(e)
opResults = None
roResults = ro.Ro_Results(
httpResultCode=result._delegate.status_code, # type=int
httpResultText=result._delegate.reason, # type=str
opResults=opResults,
opResultHeaders=result._delegate.headers,
)
icm.LOG_here(
"RESPONSE: status_code={status_code} -- reason={reason} -- text={text}"
.format(
status_code=result._delegate.status_code,
reason=result._delegate.reason,
text=result._delegate.text,
))
icm.LOG_here("RESPONSE: responseHeaders: {headers}".format(
headers=pp.pformat(result._delegate.headers)))
roOp.roResults = roResults
return roOp
def opInvoke(headers, op, *args, **kwargs):
####+END:
""" NOTYET, Important, opInvoke should be layered on top of opInvokeCapture """
pp = pprint.PrettyPrinter(indent=4)
headerLines = list()
if headers:
with open(headers, 'rb') as file:
headerLines = file.readlines()
# else:
# print("Has No Headers")
headerLinesAsDict = dict()
for each in headerLines:
headerLineAsList = each.split(":")
headerLineAsListLen = len(headerLineAsList)
if headerLineAsListLen == 2:
headerLineTag = headerLineAsList[0]
headerLineValue = headerLineAsList[1]
else:
icm.EH_problem_usageError(
"Expected 2: {}".format(headerLineAsListLen))
continue
headerLinesAsDict[headerLineTag] = headerLineValue.lstrip(' ').rstrip()
requestOptions = dict()
if headerLinesAsDict:
requestOptions["headers"] = headerLinesAsDict
def bodyArgToDict(
bodyAny,
bodyFile,
bodyStr,
bodyFunc,
):
""" Returns None if all Args were None, and returns "" if one of the args was "", Otherwize a dict or {}."""
def bodyStrAsDict(bodyStr):
return ast.literal_eval(bodyStr)
def bodyFileAsDict(bodyFile):
with open(bodyFile, 'r') as myfile:
data = myfile.read().replace('\n', '')
return ast.literal_eval(data)
def bodyFuncAsDict(bodyFunc):
resDict = eval(bodyFunc)
# NOTYET, verify that we have a dict
return resDict
if bodyAny != None:
icm.TM_here("bodyAny={}".format(pp.pformat(bodyAny)))
if bodyAny == "":
return ""
# Be it file, function or string
if os.path.isfile(bodyAny):
return bodyFileAsDict(bodyAny)
elif bodyAny == "NOTYET-valid func":
return bodyFuncAsDict(bodyAny)
else:
# We then take bodyAny to be a string
return bodyStrAsDict(bodyAny)
elif bodyFile != None:
icm.TM_here("bodyFile={}".format(pp.pformat(bodyFile)))
if bodyFile == "":
return ""
if os.path.isfile(bodyAny):
return bodyFileAsDict(bodyFile)
else:
return {}
elif bodyFunc != None:
icm.TM_here("bodyFunc={}".format(pp.pformat(bodyFunc)))
if bodyFunc == "":
return ""
if bodyFunc == "NOTYET-valid func":
return bodyFuncAsDict(bodyFunc)
else:
return {}
elif bodyStr != None:
icm.TM_here("bodyStr={}".format(pp.pformat(bodyStr)))
if bodyStr == "":
return ""
bodyValue = bodyStrAsDict(bodyStr)
return bodyValue
else:
# So they were all None, meaning that no form of "body" was specified.
return None
# icm.TM_here("Args: {}".format(args))
# for key in kwargs:
# icm.TM_here("another keyword arg: %s: %s" % (key, kwargs[key]))
bodyAny = kwargs.pop('body', None)
bodyFile = kwargs.pop('bodyFile', None)
bodyStr = kwargs.pop('bodyStr', None)
bodyFunc = kwargs.pop('bodyFunc', None)
bodyValue = bodyArgToDict(bodyAny, bodyFile, bodyStr, bodyFunc)
icm.TM_here(pp.pformat(requestOptions))
if bodyValue == None:
request = construct_request(op, requestOptions, **kwargs)
elif bodyValue == "":
# Causes An Exception That Describes Expected Dictionary
request = construct_request(op, requestOptions, body=None, **kwargs)
else:
request = construct_request(op,
requestOptions,
body=bodyValue,
**kwargs)
icm.LOG_here("request={request}".format(request=pp.pformat(request)))
c = RequestsClient()
future = c.request(request)
try:
result = future.result()
except Exception as e:
#icm.EH_critical_exception(e)
result = None
if result:
icm.LOG_here("responseHeaders: {headers}".format(
headers=pp.pformat(result._delegate.headers)))
icm.ANN_write("Operation Status: {result}".format(result=result))
icm.ANN_write("Operation Result: {result}".format(
result=pp.pformat(result.json())))
