def newhandler(request, *args, **kwargs):
key = request.COOKIES.get(SESSION_KEY_NAME)
redir = "/auth/login?redir=%s" % request.path
if not key:
return framework.HttpResponseRedirect(redir)
dbsession = models.SessionMaker()
try:
session = dbsession.query(models.Session).filter_by(session_key=key).one()
except models.NoResultFound:
resp = framework.HttpResponseRedirect(redir)
resp.delete_cookie(SESSION_KEY_NAME, domain=request.get_host())
return resp
if session.is_expired():
dbsession.delete(session)
dbsession.commit()
dbsession.close()
resp = framework.HttpResponseRedirect(redir)
resp.delete_cookie(SESSION_KEY_NAME, domain=request.get_host())
return resp
# A check to thwart cross site request forgery
referer = request.environ.get("HTTP_REFERER")
if referer is None:
request.log_error("No referer in authenticated request.\n")
resp = framework.HttpResponseRedirect("/")
resp.delete_cookie(SESSION_KEY_NAME, domain=request.get_host())
return resp
if HOSTNAME not in referer:
request.log_error("Our host not in referer.\n")
resp = framework.HttpResponseRedirect("/")
resp.delete_cookie(SESSION_KEY_NAME, domain=request.get_host())
return resp
request.session = session
return handler(request, *args, **kwargs)
def post(self, request):
try:
if request.headers["x-requested-with"].value == "XMLHttpRequest":
return handle_async_authentication(request)
else:
return framework.HttpResponseRedirect(request.get_url(login), message="Method not allowed.")
except IndexError:
return framework.HttpResponseRedirect(request.get_url(login), message="Method not allowed.")
def get(self, request):
key = request.COOKIES.get(SESSION_KEY_NAME)
if key is not None:
dbsession = models.SessionMaker()
try:
sess = dbsession.query(models.Session).filter_by(session_key=key).one()
except models.NoResultFound:
pass
else:
dbsession.delete(sess)
dbsession.commit()
dbsession.close()
request.session = None
resp = framework.HttpResponseRedirect("/")
resp.delete_cookie(SESSION_KEY_NAME, domain=request.get_host())
return resp
class TestcaseRunner(framework.RequestHandler):
def get(self, request, tcid):
dbrow = get_testcase(tcid)
title = "Run test case %r" % (dbrow.name, )
resp = framework.ResponseDocument(request,
testcase_run_constructor,
title=title)
render_testcase(resp.doc, dbrow)
if not dbrow.automated:
form = resp.doc.add_form(
action=request.resolver.get_url(testcase_run, tcid=dbrow.id))
BR = form.get_new_element("Br")
outerfs = form.add_fieldset("Run the test.")
outerfs.add_textinput("build", "Build")
outerfs.new_para(
"Build should have form: '<project>.<major>.<minor>.<subminor>.<build>'"
)
webhelpers.create_pick_list(outerfs,
models.Environment,
filtermap=None)
outerfs.append(BR)
outerfs.yes_no("Were you able to complete the test?",
name="completed")
outerfs.append(BR)
outerfs.yes_no("If so, did it pass?", name="passfail")
outerfs.append(BR)
outerfs.add_textinput("note", "Notes")
form.add_hidden("starttime", str(models.tables.time_now()))
form.add_input(type="submit", name="submit", value="OK")
else:
resp.doc.new_para("""
This is an automated test. Running automated tests from the
web interface is not yet supported.
""",
class_="error")
return resp.finalize()
def post(self, request, tcid):
dbrow = get_testcase(tcid)
data = request.POST
if data.get("completed") == "0": # yes
if data.get("passfail") == "0": # yes
result = webhelpers.PASSED
else:
result = webhelpers.FAILED
else:
result = webhelpers.INCOMPLETE
username = request.session["username"]
tester = models.User.get_by_username(webhelpers.dbsession, username)
build = webhelpers.resolve_build(data.get("build"))
rr = models.create(
models.TestResult,
objecttype=webhelpers.RUNNER,
testcase=None,
environment=webhelpers.resolve_environment(
data.get("environment")),
build=build,
tester=tester,
testversion=None,
parent=None,
starttime=data.get("starttime"),
endtime=str(models.tables.time_now()),
arguments=None,
result=result,
diagnostic=None,
note=None,
valid=True,
)
webhelpers.dbsession.add(rr)
tr = models.create(
models.TestResult,
objecttype=webhelpers.TEST,
testcase=dbrow,
environment=None,
build=build,
tester=tester,
testversion=None,
parent=rr,
starttime=data.get("starttime"),
endtime=str(models.tables.time_now()),
arguments=None,
result=result,
diagnostic=IF(result != webhelpers.PASSED, data.get("note")),
note=IF(result == webhelpers.PASSED, data.get("note")),
valid=True,
)
webhelpers.dbsession.add(tr)
try:
webhelpers.dbsession.commit()
except (DataError, IntegrityError), err:
webhelpers.dbsession.rollback()
title = "Test runner error"
resp = framework.ResponseDocument(request,
testcase_run_constructor,
title=title)
resp.doc.new_para(err, class_="error")
resp.doc.new_para(
"There was an error recording this test. Please try again.")
return resp.finalize()
return framework.HttpResponseRedirect(
request.resolver.get_url(testcase_list))
def post(self, request, tcid):
dbrow = get_testcase(tcid)
try:
webhelpers.update_row(request.POST, models.TestCase, dbrow)
except types.ValidationError, err:
webhelpers.dbsession.rollback()
resp = self.get_page(request, dbrow, err)
return resp.finalize()
try:
webhelpers.dbsession.commit()
except (DataError, IntegrityError), err:
webhelpers.dbsession.rollback()
resp = self.get_page(request, dbrow, err)
return resp.finalize()
else:
return framework.HttpResponseRedirect(
request.resolver.get_url(testcase_list))
def get_page(self, request, dbrow, error=None):
title = "Edit test case %r." % (dbrow.name, )
modelclass = models.TestCase
resp = framework.ResponseDocument(request,
testcase_edit_constructor,
title=title)
resp.new_para(title)
if error is not None:
resp.new_para(error, class_="error")
form = resp.add_form(
action=request.resolver.get_url(testcase_edit, tcid=dbrow.id))
BR = form.get_new_element("Br")
outerfs = form.add_fieldset(modelclass.__name__)
for colname in ('name', 'purpose', 'passcriteria', 'startcondition',
webhelpers.dbsession.add(dbrow)
try:
webhelpers.dbsession.commit()
except (DataError, IntegrityError), err:
webhelpers.dbsession.rollback()
request.log_error("create error: %s: %s\n" % (tablename, err))
title = "Create new %s" % (tablename, )
resp = self.get_response(request, title=title)
resp.new_para(title + ", again.")
resp.new_para(err, class_="error")
form = resp.add_form(action=request.get_url(addentry, tablename=tablename))
webhelpers.build_add_form(form, klass)
return resp.finalize()
else:
return framework.HttpResponseRedirect(request.get_url(listtable, tablename=tablename))
addentry = auth.need_login(webhelpers.setup_dbsession(CreateRequestHandler(doc_constructor)))
class EditRequestHandler(framework.RequestHandler):
def get(self, request, tablename=None, rowid=None):
klass = get_model(tablename)
dbrow = webhelpers.get_row(klass, rowid)
title = "Edit %s %s" % (tablename, dbrow)
resp = self.get_response(request, title=title)
resp.new_para(title)
form = resp.add_form(action=request.get_url(edit, tablename=tablename, rowid=rowid))
webhelpers.build_edit_form(form, klass, dbrow)