def _err_response(self, where, err):
if err:
exception_trace(where, err, logger)
try:
res = Result(self.session, self.profile_handler)
res.print_info(self.session["testid"])
res.store_test_info()
except KeyError:
pass
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)
except Exception as err:
exception_trace("", err, logger)
res = Result(self.sh, None)
res.print_info(self.sh, test_id)
return self.webio.err_response("run", err)
def urlhandler_flownames(self, sh, environ, local_webenv, path, tester, webio):
self.set_mimetype(environ)
resp = tester.run(path, **local_webenv)
store_test_state(sh, sh['conv'].events)
logfilename = local_webenv['profile_handler'](sh).log_path(path)
if isinstance(resp, Response):
res = Result(sh, local_webenv['profile_handler'])
res.store_test_info()
res.print_info(path, tester.fname(path))
return webio.respond(resp)
else:
if self.mime_type == 'application/json':
return webio.single_flow(path)
else:
return webio.flow_list(tt_entityid=webio.kwargs['entity_id'])
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 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 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
from saml2test.sp_test.tool import ClTester
from saml2test.sp_test.setup import setup
__author__ = 'roland'
logger = logging.getLogger("")
if __name__ == "__main__":
test_id, kwargs, opargs = setup()
u
sh = SessionHandler(session={}, **kwargs)
sh.t it_session(profile=kwargs['profile'])
if test_id:
res = Result(sh, kwargs['profile_handler'])
if test_id not in kwargs['flows']:
print(
"The test id ({}) does not appear in the test definitions".format(
test_id))
exit()
webio = ClIO(**kwargs)
tester = ClTester(webio, sh, **kwargs)
if tester.run(test_id, **kwargs):
res.print_info(sh, test_id)
else:
for tid in sh["flow_names"]:
# New fresh session handler for every test
_sh = SessionHandler({}, **kwargs)
_sh.init_session(profile=kwargs['profile'])
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 application(self, environ, start_response):
LOGGER.info("Connection from: %s" % environ["REMOTE_ADDR"])
session = environ['beaker.session']
path = environ.get('PATH_INFO', '').lstrip('/')
LOGGER.info("path: %s" % path)
try:
sh = session['session_info']
except KeyError:
sh = SessionHandler(**self.webenv)
sh.session_init()
session['session_info'] = sh
webio = WebIO(session=sh, **self.webenv)
webio.environ = environ
webio.start_response = start_response
tester = Tester(webio, sh, **self.webenv)
if path == "robots.txt":
return webio.static("static/robots.txt")
elif path == "favicon.ico":
return webio.static("static/favicon.ico")
elif path.startswith('acs/site/static'):
path = path[4:]
return webio.static(path)
elif path.startswith("site/static/") or path.startswith('static/'):
return webio.static(path)
elif path.startswith("export/"):
return webio.static(path)
if path == "" or path == "/": # list
return tester.display_test_list()
elif "flow_names" not in sh:
sh.session_init()
if path == "logs":
return webio.display_log("log", issuer="", profile="", testid="")
elif path.startswith("log"):
if path == "log" or path == "log/":
_cc = webio.conf.CLIENT
try:
_iss = _cc["srv_discovery_url"]
except KeyError:
_iss = _cc["provider_info"]["issuer"]
parts = [quote_plus(_iss)]
else:
parts = []
while path != "log":
head, tail = os.path.split(path)
# tail = tail.replace(":", "%3A")
# if tail.endswith("%2F"):
# tail = tail[:-3]
parts.insert(0, tail)
path = head
return webio.display_log("log", *parts)
elif path.startswith("tar"):
path = path.replace(":", "%3A")
return webio.static(path)
elif path.startswith("test_info"):
p = path.split("/")
try:
return webio.test_info(p[1])
except KeyError:
return webio.not_found()
elif path == "continue":
return tester.cont(environ, self.webenv)
elif path == 'reset':
for param in ['flow', 'flow_names', 'index', 'node', 'profile',
'sequence', 'test_info', 'test_id', 'tests']:
del sh[param]
return tester.display_test_list()
elif path == "opresult":
if tester.conv is None:
return webio.sorry_response("", "No result to report")
return webio.opresult(tester.conv, sh)
# expected path format: /<testid>[/<endpoint>]
elif path in sh["flow_names"]:
resp = tester.run(path, **self.webenv)
store_test_state(sh, sh['conv'].events)
filename = self.webenv['profile_handler'](sh).log_path(path)
if isinstance(resp, Response):
res = Result(sh, self.webenv['profile_handler'])
res.store_test_info()
res.print_info(path, tester.fname(path))
return webio.respond(resp)
else:
return webio.flow_list(filename)
elif path == "acs/post":
qs = get_post(environ).decode('utf8')
resp = dict([(k, v[0]) for k, v in parse_qs(qs).items()])
filename = self.webenv['profile_handler'](sh).log_path(tester.conv.test_id)
return do_next(tester, resp, sh, webio, filename, path)
elif path == "acs/redirect":
qs = environ['QUERY_STRING']
resp = dict([(k, v[0]) for k, v in parse_qs(qs).items()])
filename = self.webenv['profile_handler'](sh).log_path(tester.conv.test_id)
return do_next(tester, resp, sh, webio, filename, path)
elif path == "acs/artifact":
pass
elif path == "ecp":
pass
elif path == "disco":
pass
elif path == "slo":
pass
else:
resp = BadRequest()
return resp(environ, start_response)
