def run(self, test_id, **kw_args):
if not self.match_profile(test_id):
logger.info("Test doesn't match the profile")
return True
redirs = get_redirect_uris(kw_args['client_info'])
self.sh.session_setup(path=test_id)
_flow = self.flows[test_id]
_cli, _c_info = kw_args['client_factory'].make_client(
**kw_args['client_info'])
self.conv = Conversation(_flow,
_cli,
msg_factory=kw_args["msg_factory"],
callback_uris=redirs,
opid=kw_args['opid'])
_cli.conv = self.conv
_cli.event_store = self.conv.events
self.conv.entity_config = _c_info
self.conv.sequence = self.sh["sequence"]
self.conv.tool_config = kw_args['tool_conf']
self.sh["conv"] = self.conv
# noinspection PyTypeChecker
try:
return self.run_flow(test_id, conf=kw_args["conf"])
except Exception as err:
exception_trace("", err, logger)
# res = Result(self.sh, self.kwargs['profile_handler'])
# res.print_info(test_id)
return self.inut.err_response("run", err)
def run_one(test_id, flows, profile, profiles, io, sh, **kw_args):
try:
redirs = kw_args["cinfo"]["client"]["redirect_uris"]
except KeyError:
redirs = kw_args["cinfo"]["registered"]["redirect_uris"]
io = ClIO(flows=flows, profile=profile, **kw_args)
sh = SessionHandler(None, profile, flows, **kw_args)
_flow = flows[test_id]
_cli = make_client(**kw_args)
conversation = Conversation(
_flow,
_cli,
kw_args["msg_factory"],
interaction=kw_args["conf"].INTERACTION,
trace_cls=Trace,
callback_uris=redirs,
)
# noinspection PyTypeChecker
try:
run_flow(profiles, conversation, test_id, kw_args["conf"], profile, kw_args["check_factory"], io, sh)
except Exception as err:
exception_trace("", err, logger)
print(conversation.trace)
def run(self, test_id, **kw_args):
if not self.match_profile(test_id):
logger.info("Test doesn't match the profile")
return True
redirs = get_redirect_uris(kw_args['client_info'])
self.sh.session_setup(path=test_id)
_flow = self.flows[test_id]
_cli, _c_info = kw_args['client_factory'].make_client(
**kw_args['client_info'])
self.conv = Conversation(_flow, _cli,
msg_factory=kw_args["msg_factory"],
callback_uris=redirs, opid=kw_args['opid'])
_cli.conv = self.conv
_cli.event_store = self.conv.events
self.conv.entity_config = _c_info
self.conv.sequence = self.sh["sequence"]
self.conv.tool_config = kw_args['tool_conf']
self.sh["conv"] = self.conv
# noinspection PyTypeChecker
try:
return self.run_flow(test_id, conf=kw_args["conf"])
except Exception as err:
exception_trace("", err, logger)
# res = Result(self.sh, self.kwargs['profile_handler'])
# res.print_info(test_id)
return self.inut.err_response("run", err)
def run(self, test_id, **kw_args):
self.setup(test_id, **kw_args)
# noinspection PyTypeChecker
try:
return self.run_flow(test_id, conf=kw_args["conf"])
except Exception as err:
exception_trace("", err, logger)
# self.inut.dump_log(self.sh, test_id)
return self.inut.err_response("run", err)
def run(self, test_id, **kw_args):
if not self.setup(test_id, **kw_args):
raise ConfigurationError()
# noinspection PyTypeChecker
try:
return self.run_item(test_id, index=0, **kw_args)
except Exception as err:
exception_trace("", err, logger)
return self.inut.err_response("run", err)
def run(self, test_id, **kw_args):
if not self.setup(test_id, **kw_args):
raise ConfigurationError()
# noinspection PyTypeChecker
try:
return self.run_item(test_id, index=0, **kw_args)
except Exception as err:
exception_trace("", err, logger)
return self.inut.err_response("run", err)
def run(self, test_id, **kw_args):
self.setup(test_id, **kw_args)
# noinspection PyTypeChecker
try:
return self.run_flow(test_id, conf=kw_args["conf"])
except Exception as err:
exception_trace("", err, logger)
# self.inut.dump_log(self.sh, test_id)
return self.inut.err_response("run", err)
def run(self, test_id, **kw_args):
if not self.setup(test_id, **kw_args):
raise ConfigurationError()
# noinspection PyTypeChecker
try:
return self.run_flow(test_id, conf=kw_args['conf'])
except Exception as err:
exception_trace("", err, logger)
self.store_result()
return self.inut.err_response("run", err)
def run(self, test_id, **kw_args):
self.setup(test_id, **kw_args)
# noinspection PyTypeChecker
try:
return self.run_flow(test_id, conf=kw_args["conf"])
except (cherrypy.HTTPRedirect, cherrypy.HTTPError):
raise
except Exception as err:
exception_trace("", err, logger)
raise cherrypy.HTTPError(500, str(err))
def run(self, test_id, **kw_args):
self.setup(test_id, **kw_args)
# noinspection PyTypeChecker
try:
return self.run_flow(test_id, conf=kw_args["conf"])
except (cherrypy.HTTPRedirect, cherrypy.HTTPError):
raise
except Exception as err:
exception_trace("", err, logger)
raise cherrypy.HTTPError(500, str(err))
def run(self, test_id, **kw_args):
if not self.setup(test_id, **kw_args):
raise ConfigurationError()
# noinspection PyTypeChecker
try:
return self.run_flow(test_id, conf=kw_args['conf'])
except Exception as err:
exception_trace("", err, logger)
self.store_result()
return self.inut.err_response("run", err)
def run_flow(profiles,
conv,
test_id,
conf,
profile,
check_factory,
io,
sh,
index=0):
print(("==" + test_id))
conv.test_id = test_id
conv.conf = conf
if index >= len(conv.flow["sequence"]):
return None
conv.index = index
for item in conv.flow["sequence"][index:]:
if isinstance(item, tuple):
cls, funcs = item
else:
cls = item
funcs = {}
_oper = cls(conv,
io,
sh,
profile=profile,
test_id=test_id,
conf=conf,
funcs=funcs)
conv.operation = _oper
_oper.setup(profiles.PROFILEMAP)
_oper()
conv.index += 1
try:
if conv.flow["assert"]:
_ver = Verify(check_factory, conv)
_ver.test_sequence(conv.flow["tests"])
except KeyError:
pass
except Exception as err:
otest.exception_trace('run_flow', err, logger)
raise
info = assert_summation(conv.events, test_id)
return info
def cont(self, **kwargs):
path = kwargs['path']
index = int(kwargs['index'])
index += 1
self.store_result()
try:
return self.run_flow(path, index=index)
except cherrypy.HTTPRedirect:
raise
except Exception as err:
exception_trace("", err, logger)
self.store_result()
return self.inut.err_response("run", err)
def display_test_list(self):
try:
if self.sh.session_init():
return self.inut.flow_list()
else:
try:
resp = Redirect("%sopresult#%s" % (
self.kwargs['base_url'], self.sh["testid"][0]))
except KeyError:
return self.inut.flow_list()
else:
return resp(self.inut.environ, self.inut.start_response)
except Exception as err:
exception_trace("display_test_list", err)
return self.inut.err_response("session_setup", err)
def display_test_list(self, **kwargs):
try:
if self.sh.session_init():
return self.inut.flow_list()
else:
try:
resp = Redirect("%s/opresult#%s" %
(self.base_url, self.sh["testid"][0]))
except KeyError:
return self.inut.flow_list(**kwargs)
else:
return resp(self.inut.environ, self.inut.start_response)
except Exception as err:
exception_trace("display_test_list", err)
return self.inut.err_response("session_setup", err)
def cont(self, **kwargs):
path = kwargs['path']
index = int(kwargs['index'])
index += 1
self.store_result()
try:
return self.run_flow(path, index=index)
except cherrypy.HTTPRedirect:
raise
except Exception as err:
exception_trace("", err, logger)
self.store_result()
return self.inut.err_response("run", err)
def index(self):
try:
if self.sh.session_init():
return as_bytes(self.info.flow_list())
else:
try:
_url = "{}opresult#{}".format(self.kwargs['base_url'],
self.sh["testid"][0])
cherrypy.HTTPRedirect(_url)
except KeyError:
return as_bytes(self.info.flow_list())
except cherrypy.HTTPRedirect:
raise
except Exception as err:
exception_trace("display_test_list", err)
cherrypy.HTTPError(message=str(err))
def index(self):
try:
if self.sh.session_init():
return as_bytes(self.info.flow_list())
else:
try:
_url = "{}opresult#{}".format(self.kwargs['base_url'],
self.sh["testid"][0])
cherrypy.HTTPRedirect(_url)
except KeyError:
return as_bytes(self.info.flow_list())
except cherrypy.HTTPRedirect:
raise
except Exception as err:
exception_trace("display_test_list", err)
cherrypy.HTTPError(message=str(err))
def authz_cb(self, **kwargs):
if cherrypy.request.method != 'GET':
# You should only get query/fragment here using GET
return self.process_error(
'Wrong HTTP method used expected GET got "{}". Could be that '
'I got a form_post to the wrong redirect_uri'.format(
cherrypy.request.method), 'authz_cb')
_conv = self.sh["conv"]
try:
_response_mode = expected_response_mode(_conv)
except ValueError as err:
return self.process_error(err, 'authz_cb')
if _response_mode == "form_post":
return self.process_error("Expected form_post, didn't get it",
'authz_cb')
elif _response_mode == 'fragment':
try:
kwargs = cherrypy.request.params
except KeyError:
pass
else:
_conv.events.store(EV_HTTP_ARGS, kwargs, ref='authz_cb')
_conv.query_component = kwargs
return self.info.opresult_fragment()
if kwargs == {}: # This should never be the case
return self.process_error(
'Got empty response could be I got something fragment '
'encoded. Expected query response mode', 'authz_cb')
_conv.events.store(EV_RESPONSE, 'Response URL with query part')
try:
resp = self.tester.async_response(self.webenv["conf"],
response=kwargs)
except cherrypy.HTTPRedirect:
# self.tester.flows.store_test_info(self)
raise
except Break:
resp = False
self.tester.store_result()
except Exception as err:
_trace = exception_trace('authz_cb', err, logger)
_conv.events.store(EV_FAULT, _trace)
self.tester.store_result()
return self.display_exception(exception_trace=_trace)
if resp is False or resp is True:
pass
elif isinstance(resp, dict) and 'exception_trace' in resp:
return self.display_exception(**resp)
elif not isinstance(resp, int):
return resp
self.opresult()
def authz_cb(self, **kwargs):
if cherrypy.request.method != 'GET':
# You should only get query/fragment here using GET
return self.process_error(
'Wrong HTTP method used expected GET got "{}". Could be that '
'I got a form_post to the wrong redirect_uri'.format(
cherrypy.request.method), 'authz_cb')
_conv = self.sh["conv"]
try:
_response_mode = expected_response_mode(_conv)
except ValueError as err:
return self.process_error(err, 'authz_cb')
if _response_mode == "form_post":
return self.process_error("Expected form_post, didn't get it",
'authz_cb')
elif _response_mode == 'fragment':
try:
kwargs = cherrypy.request.params
except KeyError:
pass
else:
_conv.events.store(EV_HTTP_ARGS, kwargs, ref='authz_cb')
_conv.query_component = kwargs
return self.info.opresult_fragment()
if kwargs == {}: # This should never be the case
return self.process_error(
'Got empty response could be I got something fragment '
'encoded. Expected query response mode', 'authz_cb')
_conv.events.store(EV_RESPONSE, 'Response URL with query part')
try:
resp = self.tester.async_response(self.webenv["conf"],
response=kwargs)
except cherrypy.HTTPRedirect:
raise
except Break:
resp = False
self.tester.store_result()
except Exception as err:
_trace = exception_trace('authz_cb', err, logger)
_conv.events.store(EV_FAULT, _trace)
self.tester.store_result()
return self.display_exception(exception_trace=_trace)
if resp is False or resp is True:
pass
elif isinstance(resp, dict) and 'exception_trace' in resp:
return self.display_exception(**resp)
elif not isinstance(resp, int):
return resp
self.opresult()
def run_flow(profiles, conv, test_id, conf, profile, check_factory, io, sh,
index=0):
print(("==" + test_id))
conv.test_id = test_id
conv.conf = conf
if index >= len(conv.flow["sequence"]):
return None
conv.index = index
for item in conv.flow["sequence"][index:]:
if isinstance(item, tuple):
cls, funcs = item
else:
cls = item
funcs = {}
_oper = cls(conv, io, sh, profile=profile, test_id=test_id, conf=conf,
funcs=funcs)
conv.operation = _oper
_oper.setup(profiles.PROFILEMAP)
_oper()
conv.index += 1
try:
if conv.flow["assert"]:
_ver = Verify(check_factory, conv)
_ver.test_sequence(conv.flow["tests"])
except KeyError:
pass
except Exception as err:
otest.exception_trace('run_flow', err, logger)
raise
info = assert_summation(conv.events, test_id)
return info
def main(flows, profile, profiles, **kw_args):
try:
redirs = kw_args["cinfo"]["client"]["redirect_uris"]
except KeyError:
redirs = kw_args["cinfo"]["registered"]["redirect_uris"]
test_list = make_list(flows, profile, **kw_args)
for tid in test_list:
io = ClIO(flows=flows, profile=profile, **kw_args)
sh = SessionHandler(profile, flows, **kw_args)
_flow = flows[tid]
_cli, _cliconf = make_client(**kw_args)
conversation = Conversation(
_flow,
_cli,
kw_args["msg_factory"],
interaction=kw_args["conf"].INTERACTION,
trace_cls=Trace,
callback_uris=redirs,
)
_cli.conv = conversation
# noinspection PyTypeChecker
try:
info = run_flow(profiles, conversation, tid, kw_args["conf"], profile, kw_args["check_factory"], io, sh)
if info["status"] == OK:
print("+{}".format(tid))
else:
print("!{}".format(tid))
for ev in conversation.events:
print(ev)
break
except Exception as err:
exception_trace("", err, logger)
print(conversation.trace)
break
def main(flows, profile, profiles, **kw_args):
try:
redirs = kw_args["cinfo"]["client"]["redirect_uris"]
except KeyError:
redirs = kw_args["cinfo"]["registered"]["redirect_uris"]
test_list = make_list(flows, profile, **kw_args)
for tid in test_list:
io = ClIO(flows=flows, profile=profile, **kw_args)
sh = SessionHandler(profile, flows, **kw_args)
_flow = flows[tid]
_cli, _cliconf = make_client(**kw_args)
conversation = Conversation(_flow,
_cli,
kw_args["msg_factory"],
interaction=kw_args["conf"].INTERACTION,
trace_cls=Trace,
callback_uris=redirs)
_cli.conv = conversation
# noinspection PyTypeChecker
try:
info = run_flow(profiles, conversation, tid, kw_args["conf"],
profile, kw_args["check_factory"], io, sh)
if info['status'] == OK:
print('+{}'.format(tid))
else:
print('!{}'.format(tid))
for ev in conversation.events:
print(ev)
break
except Exception as err:
exception_trace("", err, logger)
print(conversation.trace)
break
def authz_post(self, **kwargs):
if cherrypy.request.method != 'POST':
return self.process_error(
'Wrong HTTP method used expected POST got "{}"'.format(
cherrypy.request.method),
'authz_post')
_conv = self.sh["conv"]
try:
_response_mode = expected_response_mode(_conv)
except ValueError as err:
return self.process_error(err, 'authz_cb')
# Can get here 2 ways, either directly if form_post is used or
# indirectly if fragment encoding
if _response_mode == 'query': # should not be here at all
if 'fragment' in kwargs:
return self.process_error(
'Expected URL with query part got fragment', 'authz_post')
else:
return self.process_error(
'Expected URL with query part got form_post', 'authz_post')
elif _response_mode == 'fragment':
if 'fragment' in kwargs: # everything OK
self.tester.conv.events.store(EV_RESPONSE,
'URL with fragment')
else:
return self.process_error(
'Expected URL with fragment part got form_post',
'authz_post')
else:
self.tester.conv.events.store(EV_RESPONSE, 'Form post')
try:
resp = self.tester.async_response(self.webenv["conf"],
response=kwargs)
except cherrypy.HTTPRedirect:
raise
except Exception as err:
_trace = exception_trace('authz_post', err, logger)
return self.display_exception(exception_trace=_trace)
# return self.info.err_response("authz_cb", err)
else:
if resp is False or resp is True:
pass
elif not isinstance(resp, int):
return resp
self.opresult()
def authz_post(self, **kwargs):
if cherrypy.request.method != 'POST':
return self.process_error(
'Wrong HTTP method used expected POST got "{}"'.format(
cherrypy.request.method),
'authz_post')
_conv = self.sh["conv"]
try:
_response_mode = expected_response_mode(_conv)
except ValueError as err:
return self.process_error(err, 'authz_cb')
# Can get here 2 ways, either directly if form_post is used or
# indirectly if fragment encoding
if _response_mode == 'query': # should not be here at all
if 'fragment' in kwargs:
return self.process_error(
'Expected URL with query part got fragment', 'authz_post')
else:
return self.process_error(
'Expected URL with query part got form_post', 'authz_post')
elif _response_mode == 'fragment':
if 'fragment' in kwargs: # everything OK
self.tester.conv.events.store(EV_RESPONSE,
'URL with fragment')
else:
return self.process_error(
'Expected URL with fragment part got form_post',
'authz_post')
else:
self.tester.conv.events.store(EV_RESPONSE, 'Form post')
try:
resp = self.tester.async_response(self.webenv["conf"],
response=kwargs)
except cherrypy.HTTPRedirect:
raise
except Exception as err:
_trace = exception_trace('authz_post', err, logger)
return self.display_exception(exception_trace=_trace)
# return self.info.err_response("authz_cb", err)
else:
if resp is False or resp is True:
pass
elif not isinstance(resp, int):
return resp
self.opresult()
def run_one(test_id, flows, profile, profiles, io, sh, **kw_args):
try:
redirs = kw_args["cinfo"]["client"]["redirect_uris"]
except KeyError:
redirs = kw_args["cinfo"]["registered"]["redirect_uris"]
io = ClIO(flows=flows, profile=profile, **kw_args)
sh = SessionHandler(None, profile, flows, **kw_args)
_flow = flows[test_id]
_cli = make_client(**kw_args)
conversation = Conversation(_flow,
_cli,
kw_args["msg_factory"],
interaction=kw_args["conf"].INTERACTION,
trace_cls=Trace,
callback_uris=redirs)
# noinspection PyTypeChecker
try:
run_flow(profiles, conversation, test_id, kw_args["conf"], profile,
kw_args["check_factory"], io, sh)
except Exception as err:
exception_trace("", err, logger)
print(conversation.trace)
def do_check(self, test, **kwargs):
logger.debug("do_check({}, {})".format(test, kwargs))
if isinstance(test, str):
try:
chk = self.check_factory(test)(**kwargs)
except TypeError:
raise MissingTest(test)
else:
chk = test(**kwargs)
if chk.__class__.__name__ not in self.ignore_check:
self.conv.events.store(EV_ASSERTION, chk.__class__.__name__)
try:
stat = chk(self.conv)
except Exception as err:
exception_trace('do_check', err, logger)
raise
else:
if self.cls_name:
stat.context = self.cls_name
self.conv.events.store(EV_CONDITION, stat,
sender=self.__class__)
self.check_severity(stat)
def _endpoint(self, ref, request=None, **kwargs):
_conv = self.sh['conv']
# continue with next operation in the sequence
self.sh["index"] += 1
item = self.sh["sequence"][self.sh["index"]]
if isinstance(item, tuple):
cls, _ = item
else:
cls = item
logger.debug('Next operation: %s (ref:%s)', cls.__name__, ref)
if LOGOUT_MAP[cls.__name__] != ref:
_conv.events.store(
EV_FAULT, "Expected {} but got {}".format(cls.__name__, ref))
self.tester.store_result()
self.opresult()
try:
resp = self.tester.handle_request(request, **kwargs)
except cherrypy.HTTPRedirect:
self.tester.flows.store_test_info(self.tester)
raise
except (Break, OperationError) as err:
resp = False
_conv.events.store(EV_FAULT, err)
self.tester.store_result()
except Exception as err:
_trace = exception_trace(ref, err, logger)
_conv.events.store(EV_FAULT, _trace)
self.tester.store_result()
return self.display_exception(exception_trace=_trace)
if resp is False or resp is True:
pass
elif resp in ["DONE", ""]:
pass
elif isinstance(resp, dict) and 'exception_trace' in resp:
return self.display_exception(**resp)
elif not isinstance(resp, int):
return resp
self.opresult()
def run(self, test):
try:
resp = self.tester.run(test, **self.webenv)
except HTTPRedirect:
raise
except Exception as err:
#test_id = list(self.flows.complete.keys())[0]
_trace = exception_trace('run', err, logger)
self.tester.conv.events.store(EV_FAULT, _trace)
return self.display_exception(exception_trace=_trace)
self.sh['session_info'] = self.info.session
if isinstance(resp, dict):
return self.display_exception(**resp)
elif resp is False or resp is True:
pass
elif isinstance(resp, list):
return conv_response(self.sh.events, resp)
elif isinstance(resp, bytes):
return resp
self.opresult()
def run(self, test):
try:
resp = self.tester.run(test, **self.webenv)
except HTTPRedirect:
raise
except Exception as err:
#test_id = list(self.flows.complete.keys())[0]
_trace = exception_trace('run', err, logger)
self.tester.conv.events.store(EV_FAULT, _trace)
return self.display_exception(exception_trace=_trace)
self.sh['session_info'] = self.info.session
if isinstance(resp, dict):
return self.display_exception(**resp)
elif resp is False or resp is True:
pass
elif isinstance(resp, list):
return conv_response(self.sh.events, resp)
elif isinstance(resp, bytes):
return resp
self.opresult()
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 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']
def _store_error(self, where, err):
if err:
exception_trace(where, err, logger)
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']
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 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 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
