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_unicode_to_utf8_encode_params(self):
httpretty.register_uri(
httpretty.GET, "http://swagger.py/client-test",
body='expected')
client = RequestsClient()
params = self._default_params()
params['params'] = {'foo': u'酒場'}
resp = client.request(params).result() # type: IncomingResponse
self.assertEqual(200, resp.status_code)
self.assertEqual('expected', resp.text)
self.assertEqual({'foo': [u'酒場']},
httpretty.last_request().querystring)
def test_simple_get(self):
httpretty.register_uri(httpretty.GET,
"http://swagger.py/client-test",
body='expected')
client = RequestsClient()
params = self._default_params()
params['params'] = {'foo': 'bar'}
resp = client.request(params).result()
self.assertEqual(200, resp.status_code)
self.assertEqual('expected', resp.text)
self.assertEqual({'foo': ['bar']},
httpretty.last_request().querystring)
def test_simple_get(self):
httpretty.register_uri(
httpretty.GET, "http://swagger.py/client-test",
body='expected')
client = RequestsClient()
params = self._default_params()
params['params'] = {'foo': 'bar'}
resp = client.request(params).result()
self.assertEqual(200, resp.status_code)
self.assertEqual('expected', resp.text)
self.assertEqual({'foo': ['bar']},
httpretty.last_request().querystring)
def test_api_key(self):
httpretty.register_uri(
httpretty.GET, "http://swagger.py/client-test",
body='expected')
client = RequestsClient()
client.set_api_key("swagger.py", 'abc123', param_name='test')
params = self._default_params()
params['params'] = {'foo': 'bar'}
resp = client.request(params).result()
self.assertEqual(200, resp.status_code)
self.assertEqual('expected', resp.text)
self.assertEqual({'foo': ['bar'], 'test': ['abc123']},
httpretty.last_request().querystring)
def test_basic_auth(self):
httpretty.register_uri(
httpretty.GET, "http://swagger.py/client-test",
body='expected')
client = RequestsClient()
client.set_basic_auth("swagger.py", 'unit', 'peekaboo')
params = self._default_params()
params['params'] = {'foo': 'bar'}
resp = client.request(params).result()
self.assertEqual(200, resp.status_code)
self.assertEqual('expected', resp.text)
self.assertEqual({'foo': ['bar']},
httpretty.last_request().querystring)
self.assertEqual('Basic %s' % base64.b64encode("unit:peekaboo"),
httpretty.last_request().headers.get('Authorization'))
def test_api_key_header(self):
httpretty.register_uri(
httpretty.GET, "http://swagger.py/client-test",
body='expected')
client = RequestsClient()
client.set_api_key("swagger.py", 'abc123', param_name='Key',
param_in='header')
params = self._default_params()
params['params'] = {'foo': 'bar'}
resp = typing.cast(IncomingResponse, client.request(params).result())
self.assertEqual(200, resp.status_code)
self.assertEqual('expected', resp.text)
self.assertEqual({'foo': ['bar']},
httpretty.last_request().querystring)
self.assertEqual('abc123', httpretty.last_request().headers['Key'])
def test_basic_auth(self):
httpretty.register_uri(
httpretty.GET, "http://swagger.py/client-test",
body='expected')
client = RequestsClient()
client.set_basic_auth("swagger.py", 'unit', 'peekaboo')
params = self._default_params()
params['params'] = {'foo': 'bar'}
resp = client.request(params).result() # type: IncomingResponse
self.assertEqual(200, resp.status_code)
self.assertEqual('expected', resp.text)
self.assertEqual({'foo': ['bar']},
httpretty.last_request().querystring)
self.assertEqual(
'Basic %s' % base64.b64encode(b"unit:peekaboo").decode('utf-8'),
httpretty.last_request().headers.get('Authorization'))
def test_real_post(self):
httpretty.register_uri(
httpretty.POST, "http://swagger.py/client-test",
body='expected', content_type='text/json')
client = RequestsClient()
params = self._default_params()
params['data'] = {'foo': 'bar'}
params['method'] = 'POST'
resp = client.request(params).result() # type: IncomingResponse
self.assertEqual(200, resp.status_code)
self.assertEqual('expected', resp.text)
self.assertEqual('application/x-www-form-urlencoded',
httpretty.last_request().headers['content-type'])
self.assertEqual(b"foo=bar",
httpretty.last_request().body)
def test_auth_leak(self):
httpretty.register_uri(
httpretty.GET, "http://hackerz.py",
body='expected')
client = RequestsClient()
client.set_basic_auth("swagger.py", 'unit', 'peekaboo')
params = self._default_params()
params['params'] = {'foo': 'bar'}
params['url'] = 'http://hackerz.py'
resp = client.request(params).result() # type: IncomingResponse
self.assertEqual(200, resp.status_code)
self.assertEqual('expected', resp.text)
self.assertEqual({'foo': ['bar']},
httpretty.last_request().querystring)
self.assertTrue(
httpretty.last_request().headers.get('Authorization') is None)
def test_api_key_header_overwrite(self):
httpretty.register_uri(
httpretty.GET, "http://swagger.py/client-test",
body='expected')
client = RequestsClient()
client.set_api_key("swagger.py", 'abc123', param_name='Key',
param_in='header')
params = self._default_params()
params['params'] = {'foo': 'bar'}
params['headers'] = {'Key': 'def456'}
resp = client.request(params).result() # type: IncomingResponse
self.assertEqual(200, resp.status_code)
self.assertEqual('expected', resp.text)
self.assertEqual({'foo': ['bar']},
httpretty.last_request().querystring)
self.assertEqual('def456', httpretty.last_request().headers['Key'])
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())))
