def do_next(tester, resp, sh, webio, filename, path):
tester.conv = tester.sh['conv']
tester.handle_response(resp, {})
store_test_state(sh, sh['conv'].events)
tester.webio.store_test_info()
tester.conv.index += 1
lix = len(tester.conv.sequence)
while tester.conv.sequence[tester.conv.index] != Done:
resp = tester.run_flow(tester.conv.test_id, index=tester.conv.index)
store_test_state(sh, sh['conv'].events)
if isinstance(resp, Response):
webio.print_info(path, filename)
return resp
if tester.conv.index >= lix:
break
if tester.conv.events.last_item(EV_CONDITION).test_id == 'Done':
pass
else:
if 'assert' in tester.conv.flow:
_ver = Verify(tester.chk_factory, tester.conv)
_ver.test_sequence(tester.conv.flow["assert"])
tester.conv.events.store(EV_CONDITION, State('Done', status=OK))
store_test_state(sh, sh['conv'].events)
tester.webio.store_test_info()
return webio.flow_list(filename)
def run_flow(self, test_id, conf=None, index=0):
logger.info("<=<=<=<=< %s >=>=>=>=>" % test_id)
_ss = self.sh.session
_ss["node"].complete = False
self.conv.test_id = test_id
self.conv.conf = conf
if index >= len(self.conv.sequence):
return None
_oper = None
for item in self.conv.sequence[index:]:
self.sh.session["index"] = index
if isinstance(item, tuple):
cls, funcs = item
else:
cls = item
funcs = {}
logger.info("<--<-- {} --- {} -->-->".format(index, cls))
try:
_oper = cls(conv=self.conv,
io=self.io,
sh=self.sh,
profile=self.profile,
test_id=test_id,
conf=conf,
funcs=funcs,
check_factory=self.check_factory,
cache=self.cache)
self.conv.operation = _oper
_oper.setup(self.profiles.PROFILEMAP)
resp = _oper()
except Break:
break
except Exception as err:
return self.io.err_response(self.sh.session, "run_sequence",
err)
else:
rsp = self.handle_response(resp, index)
if rsp:
return self.io.respond(rsp)
index += 1
try:
if self.conv.flow["tests"]:
print(">>", self.check_factory)
_ver = Verify(self.check_factory, self.conv.msg_factory,
self.conv)
_ver.test_sequence(self.conv.flow["tests"])
except KeyError:
pass
except Exception as err:
raise
else:
if isinstance(_oper, Done):
self.conv.events.store('test_output', END_TAG)
def run_flow(self, test_id, conf=None, index=0):
logger.info("<=<=<=<=< %s >=>=>=>=>" % test_id)
_ss = self.sh.session
_ss["node"].complete = False
self.conv.test_id = test_id
self.conv.conf = conf
if index >= len(self.conv.sequence):
return None
_oper = None
for item in self.conv.sequence[index:]:
self.sh.session["index"] = index
if isinstance(item, tuple):
cls, funcs = item
else:
cls = item
funcs = {}
logger.info("<--<-- {} --- {} -->-->".format(index, cls))
try:
_oper = cls(conv=self.conv, io=self.io, sh=self.sh,
profile=self.profile,
test_id=test_id, conf=conf, funcs=funcs,
check_factory=self.check_factory, cache=self.cache)
self.conv.operation = _oper
_oper.setup(self.profiles.PROFILEMAP)
resp = _oper()
except Break:
break
except Exception as err:
return self.io.err_response(self.sh.session, "run_sequence",
err)
else:
rsp = self.handle_response(resp, index)
if rsp:
return self.io.respond(rsp)
index += 1
try:
if self.conv.flow["tests"]:
print(">>", self.check_factory)
_ver = Verify(self.check_factory, self.conv.msg_factory,
self.conv)
_ver.test_sequence(self.conv.flow["tests"])
except KeyError:
pass
except Exception as err:
raise
else:
if isinstance(_oper, Done):
self.conv.events.store('test_output', END_TAG)
class TestVerify(object):
@pytest.fixture(autouse=True)
def create_vi(self):
self.conv = Conversation(None, None, None)
self.conv.events = Events()
self.conv.trace = Trace()
self.verify = Verify(check_factory, self.conv)
def test_1(self):
self.conv.events.store(EV_HTTP_RESPONSE, ResponseDummy(200))
tests = {'http_response': None}
res = self.verify.test_sequence(tests)
assert res
assert len(self.conv.events) == 2
ev = self.conv.events[EV_CONDITION]
assert len(ev) == 1
assert ev[0].status == OK
def test_2(self):
self.conv.events.store(EV_HTTP_RESPONSE, ResponseDummy(500))
tests = {'http_response': None}
try:
_ = self.verify.test_sequence(tests)
except FatalError:
pass
assert len(self.conv.events) == 2
ev = self.conv.events[EV_CONDITION]
assert len(ev) == 1
assert ev[0].status == CRITICAL
def test_3(self):
self.conv.events.store(EV_HTTP_RESPONSE, ResponseDummy(303))
tests = [('http_response', {})]
res = self.verify.test_sequence(tests)
assert res
assert len(self.conv.events) == 2
ev = self.conv.events[EV_CONDITION]
assert len(ev) == 1
assert ev[0].status == OK
def test_4(self):
self.conv.events.store(EV_HTTP_RESPONSE, ResponseDummy(303))
tests = ['http_response']
res = self.verify.test_sequence(tests)
assert res
assert len(self.conv.events) == 2
ev = self.conv.events[EV_CONDITION]
assert len(ev) == 1
assert ev[0].status == OK
def test_result(self):
try:
if self.conv.flow["tests"]:
_ver = Verify(self.chk_factory, self.conv)
_ver.test_sequence(self.conv.flow["tests"])
except KeyError:
pass
except Exception as err:
raise
if self.conv.events.last_item('operation') == Done:
self.conv.events.store(EV_CONDITION, State(END_TAG, status=OK),
sub='test_result', sender=self.__class__)
return True
else:
return False
def __call__(self, *args, **kwargs):
if self.skip:
return
else:
cls_name = self.__class__.__name__
if self.tests["pre"] or self.tests["post"]:
_ver = Verify(self.check_factory, self.conv, cls_name=cls_name)
else:
_ver = None
if self.tests["pre"]:
_ver.test_sequence(self.tests["pre"])
self.conv.trace.info("Running '{}'".format(cls_name))
res = self.run(*args, **kwargs)
if res:
return res
def acs():
tester, app_args = setup_tester()
for ev in tester.conv.events:
print(ev)
tester.handle_response(flask.request.form, {})
if 'assert' in tester.conv.flow:
_ver = Verify(app_args['check_factory'], tester.conv)
_ver.test_sequence(tester.conv.flow["assert"])
sline = 60 * "="
print("Timestamp: {}".format(in_a_while()))
print("\n", sline, "\n")
for l in trace_output(tester.conv.trace):
print(l)
print("\n", sline, "\n")
for l in condition(tester.conv.events):
print(l)
print("\n", sline, "\n")
try:
test_results = flask.session['test_results']
except KeyError:
test_results = {}
entcat_tests = dict(
[(t, entcat_test(v)) for t, v in app.config['TESTS'].items()])
test_results[tester.conv.events.get_data('test_id')[0]] = eval_state(
tester.conv.events)
check_result = ['{}: {}'.format(s.test_id, STATUSCODE[s.status]) for s in
tester.conv.events.get_data('condition')]
flask.session['test_results'] = test_results
return render_template("test_main.html",
base=tester.conv.base_url,
tests=app.config["TESTS"],
test_results=test_results,
check_result=check_result,
ec_tests=entcat_tests)
def do_next(self, resp, filename, path, **kwargs):
sh = self.sh
self.conv = sh['conv']
self.handle_response(resp, {})
store_test_state(sh, sh['conv'].events)
res = Result(sh, kwargs['profile_handler'])
res.store_test_info()
self.conv.index += 1
lix = len(self.conv.sequence)
while self.conv.sequence[self.conv.index] != Done:
resp = self.run_flow(self.conv.test_id, index=self.conv.index)
store_test_state(sh, sh['conv'].events)
if isinstance(resp, Response):
self.webio.print_info(path, filename)
return resp
if self.conv.index >= lix:
break
_done = False
for _cond in self.conv.events.get_data(EV_CONDITION):
if _cond.test_id == 'Done' and _cond.status == OK:
_done = True
break
if not _done:
self.conv.events.store(EV_CONDITION, State('Done', OK),
sender='do_next')
if 'assert' in self.conv.flow:
_ver = Verify(self.chk_factory, self.conv)
_ver.test_sequence(self.conv.flow["assert"])
store_test_state(sh, sh['conv'].events)
res.store_test_info()
return self.webio.flow_list(filename)
def run_flow(profiles, conv, test_id, conf, profile, chk_factory, 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=conv, profile=profile, test_id=test_id,
conf=conf, funcs=funcs, chk_factory=chk_factory)
conv.operation = _oper
conv.events.store('operation', _oper)
_oper.setup(profiles.PROFILEMAP)
_oper()
conv.index += 1
try:
if conv.flow["tests"]:
_ver = Verify(chk_factory, conv.msg_factory, conv)
_ver.test_sequence(conv.flow["tests"])
except KeyError:
pass
except Exception as err:
raise
info = test_summation(conv, test_id)
return info
def run_flow(self, test_id, index=0, profiles=None):
logger.info("<=<=<=<=< %s >=>=>=>=>" % test_id)
_ss = self.sh.session
try:
_ss["node"].complete = False
except KeyError:
pass
self.conv.test_id = test_id
if index >= len(self.conv.sequence):
return None
_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)
try:
_oper = cls(conv=self.conv, io=self.io, sh=self.sh,
profile=self.profile, test_id=test_id,
funcs=funcs, check_factory=self.chk_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 Exception as err:
exception_trace('run_flow', err)
self.sh.session["index"] = index
return self.io.err_response(self.sh.session, "run_sequence",
err)
else:
resp = self.com_handler(resp)
if resp:
resp = _oper.handle_response(resp.response)
if resp:
return self.io.respond(resp)
index += 1
try:
if self.conv.flow["assert"]:
_ver = Verify(self.chk_factory, self.conv.msg_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('condition', State('done', OK))
return True
def do_next(tester, resp, sh, webio, filename, path):
tester.conv = tester.sh['conv']
res = Result(tester.sh, tester.kwargs['profile_handler'])
try:
tester.handle_response(resp, {})
# store_test_state(sh, sh['conv'].events) this does actually nothing?
res.store_test_info()
except StatusError as err:
# store event to be found in assertion test
tester.conv.events.store(EV_PROTOCOL_RESPONSE,err)
msg = "{}: {}".format(err.__class__.__name__, str(err))
except ServiceProviderRequestHandlerError as err:
msg = str(err)
tester.conv.events.store(EV_CONDITION, State('SP Error', ERROR, message=msg),
sender='do_next')
tester.conv.index += 1
lix = len(tester.conv.sequence)
while tester.conv.sequence[tester.conv.index] != Done:
resp = tester.run_flow(tester.conv.test_id, index=tester.conv.index)
store_test_state(sh, sh['conv'].events)
if isinstance(resp, Response):
res.store_test_info()
return resp(webio.environ, webio.start_response)
elif resp is False:
break
if tester.conv.index >= lix:
break
_done = False
for _cond in tester.conv.events.get_data(EV_CONDITION):
if _cond.test_id == 'Done' and _cond.status == OK:
_done = True
break
if not _done:
tester.conv.events.store(EV_CONDITION, State('Done', OK),
sender='do_next')
if 'assert' in tester.conv.flow:
_ver = Verify(tester.chk_factory, tester.conv)
try:
_ver.test_sequence(tester.conv.flow["assert"])
except NoSuchEvent as err:
msg = str(err)
tester.conv.events.store(EV_CONDITION, State('Assertion Error', ERROR, message=msg),
sender='idp_test')
except Exception as err:
msg = str(err)
tester.conv.events.store(EV_CONDITION, State('Assertion Test Program Error', ERROR, message=msg),
sender='idp_test')
msg = "ERROR Assertion verification had gone wrong."
raise Exception(msg)
store_test_state(sh, sh['conv'].events)
res.store_test_info()
html_page = webio.flow_list(logfilename=filename, tt_entityid=webio.kwargs['entity_id'])
return html_page
def create_vi(self):
self.conv = Conversation(None, None, None)
self.conv.events = Events()
self.conv.trace = Trace()
self.verify = Verify(check_factory, self.conv)
def run_flow(self, test_id, index=0, profiles=None, **kwargs):
logger.info("<=<=<=<=< %s >=>=>=>=>" % test_id)
_ss = self.sh
try:
_ss["node"].complete = 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
_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, webio=self.webio, sh=self.sh,
profile=self.profile, test_id=test_id,
funcs=funcs, check_factory=self.chk_factory,
cache=self.cache)
# self.conv.operation = _oper
if profiles:
profile_map = profiles.PROFILEMAP
else:
profile_map = None
_oper.setup(profile_map)
oper_response = _oper()
except ConditionError:
store_test_state(self.sh, self.conv.events)
res.store_test_info()
res.print_info(test_id, self.fname(test_id))
return False
except Exception as err:
exception_trace('run_flow', err)
self.conv.events.store(EV_FAULT, err)
# self.sh["index"] = index
store_test_state(self.sh, self.conv.events)
res.store_test_info()
res.print_info(test_id, self.fname(test_id))
return False
else:
# *?*
#if isinstance(oper_response, self.response_cls):
# return oper_response
if oper_response:
if False:
return oper_response
if self.com_handler:
self.com_handler.conv = self.conv
#self.com_handler.auto_close_urls = self.my_endpoints()
self.com_handler.verify_ssl = True
if self.kwargs['conf'].DO_NOT_VALIDATE_TLS:
self.com_handler.verify_ssl = False
com_handler_response = self.com_handler(oper_response)
if com_handler_response.status == HandlerResponse.STATUS_NOT_TRIGGERED:
return oper_response
if com_handler_response.status == HandlerResponse.STATUS_NO_INTERACTION_FOUND:
response = self.webio.respond(com_handler_response)
return response
if com_handler_response.status == HandlerResponse.STATUS_ERROR:
msg = 'Com handler failed to process interaction'
self.conv.events.store(EV_CONDITION, State('Assertion Error', ERROR, message=msg),
sender='wb_tool')
store_test_state(self.sh, self.conv.events)
res.store_test_info()
res.print_info(test_id, self.fname(test_id))
return False
"""
Guesswork about what was intended to happen here.
Cases:
1. If it is an saml2.httputil.Redirect, it should be handle by the browser.
Are there other cases?
"""
if isinstance(oper_response, Redirect):
# saml2.httputil.Redirect
return oper_response
if False:
"""
Basically, now clear idea what this code whas expected to do ?
Was this just a draft? Really working with all test flavours?
"""
if com_handler_response.content_processed:
oper_response = _oper.handle_response(self.get_response(oper_response))
if oper_response:
return self.webio.respond(oper_response)
else:
return oper_response
# should be done as late as possible, so all processing has been
# done
try:
_oper.post_tests()
except ConditionError:
store_test_state(self.sh, self.conv.events)
res.store_test_info()
res.print_info(test_id, self.fname(test_id))
return False
index += 1
_ss['index'] = self.conv.index = index
try:
if self.conv.flow["assert"]:
_ver = Verify(self.chk_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')
store_test_state(self.sh, self.conv.events)
res.store_test_info()
res.print_info(test_id, self.fname(test_id))
else:
store_test_state(self.sh, self.conv.events)
res.store_test_info()
return True
def run_flow(self, test_id, index=0, profiles=None, **kwargs):
logger.info("<=<=<=<=< %s >=>=>=>=>" % test_id)
_ss = self.sh
try:
_ss["node"].complete = 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
_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.chk_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:
store_test_state(self.sh, self.conv.events)
res.store_test_info()
res.print_info(test_id, self.fname(test_id))
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):
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:
store_test_state(self.sh, self.conv.events)
res.store_test_info()
res.print_info(test_id, self.fname(test_id))
return False
index += 1
_ss['index'] = self.conv.index = index
try:
if self.conv.flow["assert"]:
_ver = Verify(self.chk_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')
store_test_state(self.sh, self.conv.events)
res.store_test_info()
res.print_info(test_id, self.fname(test_id))
else:
store_test_state(self.sh, self.conv.events)
res.store_test_info()
return True
def post_tests(self):
if self.tests["post"]:
cls_name = self.__class__.__name__
_ver = Verify(self.check_factory, self.conv, cls_name=cls_name)
_ver.test_sequence(self.tests["post"])
