def run_return_types(test_id, oper_id, kwargs, return_types, single=True):
for rtyp in return_types:
kwargs['profile'] = rtyp
kwargs['opid'] = oper_id + '_' + rtyp
kwargs['tool_conf']['tag'] = kwargs['opid']
sh = SessionHandler(**kwargs)
sh.init_session(profile=rtyp)
res = Result(sh, SimpleProfileHandler)
io = ClIO(**kwargs)
io.session = sh
tester = ClTester(io, sh, **kwargs)
if single:
tester.run(test_id, **kwargs)
res.store_test_info()
res.write_info(test_id)
return True
else:
if not tester.match_profile(test_id):
continue
elif tester.run(test_id, **kwargs):
print('+ {}'.format(test_id))
return True
else:
res = Result(sh, SimpleProfileHandler)
res.result()
return False
def process_error(self, msg, context):
# test_id = list(self.flows.complete.keys())[0]
self.tester.conv.events.store(EV_RESPONSE, msg)
self.tester.conv.events.store(EV_FAULT, 'Error in {}'.format(context))
# self.tester.conv.events.store(EV_CONDITION, State('Done', status=OK))
res = Result(self.sh, self.flows.profile_handler)
self.tester.store_result(res)
logger.error('Encountered: {} in "{}"'.format(msg, context))
self.opresult()
def store_result(self, res=None):
tinfo = self.flows.store_test_info(self)
if res is None:
res = Result(self.sh, self.kwargs['profile_handler'])
res.write_info(tinfo)
return tinfo
def run_item(self, test_id, index, profiles=None, **kw_args):
logger.info("<=<=<=<=< %s >=>=>=>=>" % test_id)
_ss = self.sh
try:
_ss.test_flows.complete[test_id] = False
except KeyError:
pass
self.conv.test_id = test_id
res = Result(self.sh, self.kwargs['profile_handler'])
if index >= len(self.conv.sequence):
return None
try:
internal = kw_args['internal']
except KeyError:
internal = True
cls, funcs = self.get_cls_and_func(index)
try:
_name = cls.__name__
except AttributeError:
_name = 'none'
logger.info("<--<-- {} --- {} -->-->".format(index, _name))
self.conv.events.store(EV_OPERATION, _name, sender='run_flow')
try:
_oper = cls(conv=self.conv,
inut=self.inut,
sh=self.sh,
profile=self.profile,
test_id=test_id,
funcs=funcs,
check_factory=self.chk_factory,
cache=self.cache,
internal=internal)
# self.conv.operation = _oper
if profiles:
profile_map = profiles.PROFILEMAP
else:
profile_map = None
_oper.setup(profile_map)
resp = _oper()
except ConditionError:
self.store_result(res)
return False
except Exception as err:
exception_trace('run_flow', err)
self.sh["index"] = index
return self.inut.err_response("run_sequence", err)
else:
if isinstance(resp, self.response_cls):
if self.conv.sequence[index + 1] == Done:
self.post_op(_oper, res, test_id)
return resp
if resp:
if self.conv.sequence[index + 1] == Done:
self.post_op(_oper, res, test_id)
return resp
# should be done as late as possible, so all processing has been
# done
try:
_oper.post_tests()
except ConditionError:
self.store_result(res)
return False
_ss['index'] = self.conv.index = index + 1
return True
def main_page(self):
res = Result(self.sh, self.flows.profile_handler)
self.tester.store_result(res)
return self.display()
def run_flow(self, test_id, index=0, profiles=None, **kwargs):
logger.info("<=<=<=<=< %s >=>=>=>=>" % test_id)
_ss = self.sh
_ss.test_flows.complete[test_id] = False
self.conv.test_id = test_id
res = Result(self.sh, self.kwargs['profile_handler'])
if index >= len(self.conv.sequence):
return CRITICAL
_oper = None
for item in self.conv.sequence[index:]:
if isinstance(item, tuple):
cls, funcs = item
else:
cls = item
funcs = {}
logger.info("<--<-- {} --- {} -->-->".format(index, cls))
self.conv.events.store('operation', cls, sender='run_flow')
try:
_oper = cls(conv=self.conv,
inut=self.inut,
sh=self.sh,
profile=self.profile,
test_id=test_id,
funcs=funcs,
check_factory=self.check_factory,
cache=self.cache)
# self.conv.operation = _oper
if profiles:
profile_map = profiles.PROFILEMAP
else:
profile_map = None
_oper.setup(profile_map)
resp = _oper()
except ConditionError:
self.store_result(res)
return ERROR
except Exception as err:
exception_trace('run_flow', err)
self.conv.events.store(EV_FAULT, err)
#self.sh["index"] = index
self.store_result(res)
return CRITICAL
else:
if isinstance(resp, self.response_cls):
return resp
if resp:
if self.com_handler:
resp = self.com_handler(resp)
resp = _oper.handle_response(self.get_response(resp))
if resp:
return self.inut.respond(resp)
# should be done as late as possible, so all processing has been
# done
try:
_oper.post_tests()
except ConditionError:
tinfo = self.store_result(res)
return tinfo['state']
index += 1
_ss['index'] = self.conv.index = index
try:
if self.conv.flow["assert"]:
_ver = Verify(self.check_factory, self.conv)
_ver.test_sequence(self.conv.flow["assert"])
except KeyError:
pass
except Exception as err:
logger.error(err)
raise
if isinstance(_oper, Done):
self.conv.events.store(EV_CONDITION,
State('Done', OK),
sender='run_flow')
tinfo = self.store_result(res)
return tinfo['state']
def store_result(self, res=None):
tinfo = self.flows.store_test_info(self)
if res is None:
res = Result(self.sh, self.kwargs['profile_handler'])
res.write_info(tinfo)
return tinfo
def run_flow(self, test_id, index=0, profiles=None, conf=None):
logger.info("<=<=<=<=< %s >=>=>=>=>" % test_id)
self.flows.complete[test_id] = False
self.conv.test_id = test_id
self.conv.conf = conf
if index >= len(self.conv.sequence):
return CRITICAL
res = Result(self.sh, self.kwargs['profile_handler'])
_oper = None
for item in self.conv.sequence[index:]:
self.sh["index"] = index
if isinstance(item, tuple):
cls, funcs = item
else:
cls = item
funcs = {}
_name = cls.__name__
_line = "<--<-- {} --- {} -->-->".format(index, _name)
logger.info(_line)
self.conv.events.store(EV_OPERATION, _line)
try:
_oper = cls(conv=self.conv,
inut=self.inut,
sh=self.sh,
profile=self.sh.profile,
test_id=test_id,
conf=conf,
funcs=funcs,
check_factory=self.check_factory,
cache=self.cache,
tool_conf=self.kwargs['tool_conf'])
self.conv.operation = _oper
_oper.setup(self.profiles.PROFILEMAP)
if _oper.fail:
break
resp = _oper()
except Break:
break
except cherrypy.HTTPError:
raise
except Exception as err:
self.conv.events.store(
EV_CONDITION,
State(test_id=test_id,
status=ERROR,
message=err,
context=cls.__name__))
_trace = exception_trace(cls.__name__, err, logger)
self.sh["index"] = index
self.store_result(res)
return {'exception_trace': _trace}
else:
rsp = self.handle_response(resp, index)
if rsp:
self.store_result(res)
return self.inut.respond(rsp)
index += 1
if index == len(self.conv.sequence):
break
if isinstance(_oper, Done):
try:
if self.conv.flow["assert"]:
_ver = Verify(self.check_factory, self.conv)
_ver.test_sequence(self.conv.flow["assert"])
except (KeyError, Break):
self.conv.events.store(EV_CONDITION, State('Done', status=OK))
except ConditionError:
pass
except Exception as err:
raise
else:
self.conv.events.store(EV_CONDITION, State('Done', status=OK))
tinfo = self.store_result(res)
return tinfo['state']