class AddStatementHandler(BaseHandler):
"""Add a statement to a task.
"""
@require_permission(BaseHandler.PERMISSION_ALL)
def get(self, task_id):
task = self.safe_get_item(Task, task_id)
self.r_params = self.render_params()
self.r_params["task"] = task
self.render("add_statement.html", **self.r_params)
@require_permission(BaseHandler.PERMISSION_ALL)
def post(self, task_id):
fallback_page = self.url("task", task_id, "statements", "add")
task = self.safe_get_item(Task, task_id)
language = self.get_argument("language", "")
if len(language) == 0:
self.service.add_notification(
make_datetime(), "No language code specified",
"The language code can be any string.")
self.redirect(fallback_page)
return
statement = self.request.files["statement"][0]
if not statement["filename"].endswith(".pdf"):
self.service.add_notification(
make_datetime(), "Invalid task statement",
"The task statement must be a .pdf file.")
self.redirect(fallback_page)
return
task_name = task.name
self.sql_session.close()
try:
digest = self.service.file_cacher.put_file_content(
statement["body"],
"Statement for task %s (lang: %s)" % (task_name, language))
except Exception as error:
self.service.add_notification(make_datetime(),
"Task statement storage failed",
repr(error))
self.redirect(fallback_page)
return
# TODO verify that there's no other Statement with that language
# otherwise we'd trigger an IntegrityError for constraint violation
self.sql_session = Session()
task = self.safe_get_item(Task, task_id)
self.contest = task.contest
statement = Statement(language, digest, task=task)
self.sql_session.add(statement)
if self.try_commit():
self.redirect(self.url("task", task_id))
else:
self.redirect(fallback_page)
def test_yisheng(self):
from cms.db.orm import DiZhi, DanWei, YiSheng
dizhi = DiZhi("中国", "湖南", "湘潭市", "湘潭县云湖桥镇北岸村道林组83号")
danwei = DanWei("任之堂")
yisheng = YiSheng('余浩', 1, date(2015, 4, 2), '13673265859')
danwei.yishengs = [yisheng]
danwei.dizhi = dizhi
Session.add(danwei)
Session.commit()
items = Session.query(DanWei).filter(DanWei.mingcheng == "任之堂").first()
self.assertEqual(items.dizhi.jiedao, u"湘潭县云湖桥镇北岸村道林组83号")
items = Session.query(YiSheng).join(DanWei).filter(
DanWei.mingcheng == "任之堂").first()
self.assertEqual(items.danwei.dizhi.jiedao, u"湘潭县云湖桥镇北岸村道林组83号")
self.assertEqual(items.danwei.yishengs[0], items)
items = Session.query(DanWei).all()
items.extend(Session.query(DiZhi).all())
items.extend(Session.query(YiSheng).all())
for m in items:
Session.delete(m)
Session.commit()
def test_chufang_yao(self):
from cms.db.orm import Yao, YaoXing, YaoWei, JingLuo, ChuFang, Yao_ChuFang_Asso
yaowei = YaoWei("酸")
yaoxing = YaoXing("寒")
jingluo = JingLuo("足厥阴肝经")
yao = Yao("白芍")
chufang = ChuFang("桂枝汤")
yao_chufang = Yao_ChuFang_Asso(yao, chufang, 7, "加热稀粥")
yao.yaowei = yaowei
yao.yaoxing = yaoxing
yao.guijing = [jingluo]
Session.add(yao)
Session.add(yaowei)
Session.add(yaoxing)
Session.add(jingluo)
Session.add(yao_chufang)
Session.commit()
items = Session.query(Yao.mingcheng,
YaoWei.wei).filter(YaoWei.wei == "酸").all()
self.assertEqual(len(items), 1)
items = Session.query(JingLuo).all()
self.assertEqual(len(items), 1)
items = Session.query(Yao).all()
items.extend(Session.query(YaoXing).all())
items.extend(Session.query(YaoWei).all())
items.extend(Session.query(JingLuo).all())
items.extend(Session.query(ChuFang).all())
for m in items:
Session.delete(m)
Session.commit()
class AddStatementHandler(BaseHandler):
"""Add a statement to a task.
"""
@require_permission(BaseHandler.PERMISSION_ALL)
def get(self, task_id):
task = self.safe_get_item(Task, task_id)
self.r_params = self.render_params()
self.r_params["task"] = task
self.render("add_statement.html", **self.r_params)
@require_permission(BaseHandler.PERMISSION_ALL)
def post(self, task_id):
fallback_page = "/task/%s/statements/add" % task_id
task = self.safe_get_item(Task, task_id)
language = self.get_argument("language", None)
if language is None:
self.application.service.add_notification(
make_datetime(), "No language code specified",
"The language code can be any string.")
self.redirect(fallback_page)
return
statement = self.request.files["statement"][0]
if not statement["filename"].endswith(".pdf"):
self.application.service.add_notification(
make_datetime(), "Invalid task statement",
"The task statement must be a .pdf file.")
self.redirect(fallback_page)
return
task_name = task.name
self.sql_session.close()
try:
digest = self.application.service.file_cacher.put_file_content(
statement["body"],
"Statement for task %s (lang: %s)" % (task_name, language))
except Exception as error:
self.application.service.add_notification(
make_datetime(), "Task statement storage failed", repr(error))
self.redirect(fallback_page)
return
# TODO verify that there's no other Statement with that language
# otherwise we'd trigger an IntegrityError for constraint violation
self.sql_session = Session()
task = self.safe_get_item(Task, task_id)
self.contest = task.contest
statement = Statement(language, digest, task=task)
self.sql_session.add(statement)
if self.try_commit():
self.redirect("/task/%s" % task_id)
else:
self.redirect(fallback_page)
def main():
# Get session
session = Session()
# Apre una sessione e lista i forum
# forums = session.query(Forum).all()
forums = session.query(forum.Forum).all()
print "Forums found: ", len(forums)
params = {'title': "Discussioni sul sito", 'description': "Per malfunzionamenti, dubbi o suggerimenti relativi al sito."}
my_forum = forum.Forum(**params)
session.add(my_forum)
session.commit()
def test_dizhi(self):
from cms.db.orm import DiZhi
dizhi = DiZhi("中国", "湖南", "湘潭市", "湘潭县云湖桥镇北岸村道林组83号")
Session.add(dizhi)
Session.commit()
items = Session.query(DiZhi.jiedao).filter(DiZhi.sheng == "湖南").first()
self.assertEqual(items[0], u"湘潭县云湖桥镇北岸村道林组83号")
items = Session.query(DiZhi).all()
for m in items:
Session.delete(m)
Session.commit()
def test_yaowei(self):
from cms.db.orm import YaoWei
yaowei = YaoWei("酸")
Session.add(yaowei)
Session.commit()
suan = Session.query(YaoWei).filter(YaoWei.wei == "酸").all()
self.assertEqual(len(suan), 1)
for xing in suan:
Session.delete(xing)
Session.commit()
suan = Session.query(YaoWei).all()
self.assertEqual(bool(suan), False)
def test_yaoxing(self):
from cms.db.orm import YaoXing
yaoxing = YaoXing("寒")
Session.add(yaoxing)
Session.commit()
suan = Session.query(YaoXing).filter(YaoXing.xing == "寒").all()
self.assertEqual(len(suan), 1)
suan = Session.query(YaoXing).all()
for xing in suan:
Session.delete(xing)
Session.commit()
suan = Session.query(YaoXing).all()
self.assertEqual(bool(suan), False)
def test_jingluo(self):
from cms.db.orm import JingLuo
item = JingLuo("足少阳胆经")
Session.add(item)
Session.commit()
items = Session.query(JingLuo).filter(
JingLuo.mingcheng == "足少阳胆经").all()
self.assertEqual(len(items), 1)
for m in items:
Session.delete(m)
Session.commit()
items = Session.query(JingLuo).all()
self.assertEqual(bool(items), False)
class AddManagerHandler(BaseHandler):
"""Add a manager to a dataset.
"""
@require_permission(BaseHandler.PERMISSION_ALL)
def get(self, dataset_id):
dataset = self.safe_get_item(Dataset, dataset_id)
task = dataset.task
self.contest = task.contest
self.r_params = self.render_params()
self.r_params["task"] = task
self.r_params["dataset"] = dataset
self.render("add_manager.html", **self.r_params)
@require_permission(BaseHandler.PERMISSION_ALL)
def post(self, dataset_id):
fallback_page = self.url("dataset", dataset_id, "managers", "add")
dataset = self.safe_get_item(Dataset, dataset_id)
task = dataset.task
manager = self.request.files["manager"][0]
task_name = task.name
self.sql_session.close()
try:
digest = self.service.file_cacher.put_file_content(
manager["body"],
"Task manager for %s" % task_name)
except Exception as error:
self.service.add_notification(
make_datetime(),
"Manager storage failed",
repr(error))
self.redirect(fallback_page)
return
self.sql_session = Session()
dataset = self.safe_get_item(Dataset, dataset_id)
task = dataset.task
manager = Manager(manager["filename"], digest, dataset=dataset)
self.sql_session.add(manager)
if self.try_commit():
self.redirect(self.url("task", task.id))
else:
self.redirect(fallback_page)
class AddManagerHandler(BaseHandler):
"""Add a manager to a dataset.
"""
@require_permission(BaseHandler.PERMISSION_ALL)
def get(self, dataset_id):
dataset = self.safe_get_item(Dataset, dataset_id)
task = dataset.task
self.contest = task.contest
self.r_params = self.render_params()
self.r_params["task"] = task
self.r_params["dataset"] = dataset
self.render("add_manager.html", **self.r_params)
@require_permission(BaseHandler.PERMISSION_ALL)
def post(self, dataset_id):
fallback_page = self.url("dataset", dataset_id, "managers", "add")
dataset = self.safe_get_item(Dataset, dataset_id)
task = dataset.task
manager = self.request.files["manager"][0]
task_name = task.name
self.sql_session.close()
try:
digest = self.service.file_cacher.put_file_content(
manager["body"],
"Task manager for %s" % task_name)
except Exception as error:
self.service.add_notification(
make_datetime(),
"Manager storage failed",
repr(error))
self.redirect(fallback_page)
return
self.sql_session = Session()
dataset = self.safe_get_item(Dataset, dataset_id)
task = dataset.task
manager = Manager(manager["filename"], digest, dataset=dataset)
self.sql_session.add(manager)
if self.try_commit():
self.redirect(self.url("task", task.id))
else:
self.redirect(fallback_page)
class AddAttachmentHandler(BaseHandler):
"""Add an attachment to a task.
"""
@require_permission(BaseHandler.PERMISSION_ALL)
def get(self, task_id):
task = self.safe_get_item(Task, task_id)
self.contest = task.contest
self.r_params = self.render_params()
self.r_params["task"] = task
self.render("add_attachment.html", **self.r_params)
@require_permission(BaseHandler.PERMISSION_ALL)
def post(self, task_id):
fallback_page = self.url("task", task_id, "attachments", "add")
task = self.safe_get_item(Task, task_id)
attachment = self.request.files["attachment"][0]
task_name = task.name
self.sql_session.close()
try:
digest = self.service.file_cacher.put_file_content(
attachment["body"],
"Task attachment for %s" % task_name)
except Exception as error:
self.service.add_notification(
make_datetime(),
"Attachment storage failed",
repr(error))
self.redirect(fallback_page)
return
# TODO verify that there's no other Attachment with that filename
# otherwise we'd trigger an IntegrityError for constraint violation
self.sql_session = Session()
task = self.safe_get_item(Task, task_id)
attachment = Attachment(attachment["filename"], digest, task=task)
self.sql_session.add(attachment)
if self.try_commit():
self.redirect(self.url("task", task_id))
else:
self.redirect(fallback_page)
class AddSpoilerHandler(BaseHandler):
"""Add a spoiler to a task.
"""
@require_permission(BaseHandler.PERMISSION_ALL)
def get(self, task_id):
task = self.safe_get_item(Task, task_id)
self.contest = task.contest
self.r_params = self.render_params()
self.r_params["task"] = task
self.render("add_spoiler.html", **self.r_params)
@require_permission(BaseHandler.PERMISSION_ALL)
def post(self, task_id):
fallback_page = self.url("task", task_id, "spoiler", "add")
task = self.safe_get_item(Task, task_id)
spoiler = self.request.files["spoiler"][0]
task_name = task.name
self.sql_session.close()
try:
digest = self.service.file_cacher.put_file_content(
spoiler["body"],
"Task spoiler for %s" % task_name)
except Exception as error:
self.service.add_notification(
make_datetime(),
"Spoiler storage failed",
repr(error))
self.redirect(fallback_page)
return
# TODO verify that there's no other Spoiler with that filename
# otherwise we'd trigger an IntegrityError for constraint violation
self.sql_session = Session()
task = self.safe_get_item(Task, task_id)
spoiler = Spoiler(spoiler["filename"], digest, task=task)
self.sql_session.add(spoiler)
if self.try_commit():
self.redirect(self.url("task", task_id))
else:
self.redirect(fallback_page)
class AddAttachmentHandler(BaseHandler):
"""Add an attachment to a task.
"""
@require_permission(BaseHandler.PERMISSION_ALL)
def get(self, task_id):
task = self.safe_get_item(Task, task_id)
self.r_params = self.render_params()
self.r_params["task"] = task
self.render("add_attachment.html", **self.r_params)
@require_permission(BaseHandler.PERMISSION_ALL)
def post(self, task_id):
fallback_page = "/task/%s/attachments/add" % task_id
task = self.safe_get_item(Task, task_id)
attachment = self.request.files["attachment"][0]
task_name = task.name
self.sql_session.close()
try:
digest = self.application.service.file_cacher.put_file_content(
attachment["body"],
"Task attachment for %s" % task_name)
except Exception as error:
self.application.service.add_notification(
make_datetime(),
"Attachment storage failed",
repr(error))
self.redirect(fallback_page)
return
# TODO verify that there's no other Attachment with that filename
# otherwise we'd trigger an IntegrityError for constraint violation
self.sql_session = Session()
task = self.safe_get_item(Task, task_id)
attachment = Attachment(attachment["filename"], digest, task=task)
self.sql_session.add(attachment)
if self.try_commit():
self.redirect("/task/%s" % task_id)
else:
self.redirect(fallback_page)
def test_danwei(self):
from cms.db.orm import DiZhi, DanWei
dizhi = DiZhi("中国", "湖南", "湘潭市", "湘潭县云湖桥镇北岸村道林组83号")
danwei = DanWei("任之堂")
danwei.dizhi = dizhi
Session.add(danwei)
Session.commit()
items = Session.query(DanWei).filter(DanWei.mingcheng == "任之堂").first()
self.assertEqual(items.dizhi.jiedao, u"湘潭县云湖桥镇北岸村道林组83号")
items = Session.query(DanWei).all()
items.extend(Session.query(DiZhi).all())
for m in items:
Session.delete(m)
Session.commit()
def test_bingren(self):
from cms.db.orm import ChuFang, BingRen, DiZhi
dizhi = DiZhi("中国", "湖南", "湘潭市", "湘潭县云湖桥镇北岸村道林组83号")
bingren = BingRen('张三', 1, date(2015, 4, 2), '13673265899')
bingren.dizhi = dizhi
Session.add(bingren)
Session.commit()
items = Session.query(BingRen).filter(
BingRen.dianhua == "13673265899").first()
self.assertEqual(items.dizhi.jiedao, u"湘潭县云湖桥镇北岸村道林组83号")
items = Session.query(BingRen).join(DiZhi).filter(
DiZhi.sheng == "湖南").first()
self.assertEqual(items.dizhi.jiedao, u"湘潭县云湖桥镇北岸村道林组83号")
items = Session.query(BingRen).all()
items.extend(Session.query(DiZhi).all())
for m in items:
Session.delete(m)
Session.commit()
class TestCaseWithDatabase(unittest.TestCase):
"""TestCase subclass starting with a clean testing database."""
@classmethod
def setUpClass(cls):
assert "fortesting" in str(cms.db.engine), \
"Monkey patching of DB connection string failed"
drop_db()
init_db()
cls.connection = cms.db.engine.connect()
cms.db.metadata.create_all(cls.connection)
@classmethod
def tearDownClass(cls):
drop_db()
cls.connection.close()
cms.db.engine.dispose()
def setUp(self):
self.session = Session()
def tearDown(self):
self.session.rollback()
def delete_data(self):
"""Delete all the data in the DB.
This is useful to call during tear down, for tests that rely on
starting from a clean DB.
"""
for table in itervalues(Base.metadata.tables):
self.session.execute(table.delete())
self.session.commit()
@staticmethod
def add_fsobject(digest, content):
dbbackend = DBBackend()
fobj = dbbackend.create_file(digest)
fobj.write(content)
dbbackend.commit_file(fobj, digest)
@staticmethod
def get_contest(**kwargs):
"""Create a contest"""
args = {
"name": unique_unicode_id(),
"description": unique_unicode_id(),
}
args.update(kwargs)
contest = Contest(**args)
return contest
def add_contest(self, **kwargs):
"""Create a contest and add it to the session"""
contest = self.get_contest(**kwargs)
self.session.add(contest)
return contest
@staticmethod
def get_user(**kwargs):
"""Create a user"""
args = {
"username": unique_unicode_id(),
"password": "",
"first_name": unique_unicode_id(),
"last_name": unique_unicode_id(),
}
args.update(kwargs)
user = User(**args)
return user
def add_user(self, **kwargs):
"""Create a user and add it to the session"""
user = self.get_user(**kwargs)
self.session.add(user)
return user
@staticmethod
def get_participation(user=None, contest=None, **kwargs):
"""Create a participation"""
user = user if user is not None else TestCaseWithDatabase.get_user()
contest = contest \
if contest is not None else TestCaseWithDatabase.get_contest()
args = {
"user": user,
"contest": contest,
}
args.update(kwargs)
participation = Participation(**args)
return participation
def add_participation(self, **kwargs):
"""Create a participation and add it to the session"""
participation = self.get_participation(**kwargs)
self.session.add(participation)
return participation
@staticmethod
def get_task(**kwargs):
"""Create a task"""
args = {
"name": unique_unicode_id(),
"title": unique_unicode_id(),
}
args.update(kwargs)
task = Task(**args)
return task
def add_task(self, **kwargs):
"""Create a task and add it to the session"""
task = self.get_task(**kwargs)
self.session.add(task)
return task
def add_statement(self, task=None, **kwargs):
"""Create a statement and add it to the session"""
task = task if task is not None else self.add_task()
args = {
"task": task,
"digest": unique_digest(),
"language": unique_unicode_id(),
}
args.update(kwargs)
statement = Statement(**args)
self.session.add(statement)
return statement
@staticmethod
def get_dataset(task=None, **kwargs):
"""Create a dataset"""
task = task if task is not None else TestCaseWithDatabase.get_task()
args = {
"task": task,
"description": unique_unicode_id(),
"task_type": "",
# "None" won't work here as the column is defined as non
# nullable. As soon as we'll depend on SQLAlchemy 1.1 we
# will be able to put JSON.NULL here instead.
"task_type_parameters": {},
"score_type": "",
# Same here.
"score_type_parameters": {},
}
args.update(kwargs)
dataset = Dataset(**args)
return dataset
def add_dataset(self, **kwargs):
"""Create a dataset and add it to the session"""
dataset = self.get_dataset(**kwargs)
self.session.add(dataset)
return dataset
def add_testcase(self, dataset=None, **kwargs):
"""Add a testcase."""
dataset = dataset if dataset is not None else self.add_dataset()
args = {
"dataset": dataset,
"codename": unique_unicode_id(),
"input": unique_digest(),
"output": unique_digest(),
}
args.update(kwargs)
testcase = Testcase(**args)
self.session.add(testcase)
return testcase
def add_submission(self, task=None, participation=None, **kwargs):
"""Add a submission."""
if task is None:
task = self.add_task(contest=self.add_contest())
participation = participation \
if participation is not None \
else self.add_participation(contest=task.contest)
assert task.contest == participation.contest
args = {
"task": task,
"participation": participation,
"timestamp": (task.contest.start + timedelta(0, unique_long_id())),
}
args.update(kwargs)
submission = Submission(**args)
self.session.add(submission)
return submission
def add_file(self, submission=None, **kwargs):
"""Create a file and add it to the session"""
if submission is None:
submission = self.add_sbubmission()
args = {
"submission": submission,
"filename": unique_unicode_id(),
"digest": unique_digest(),
}
args.update(kwargs)
file = File(**args)
self.session.add(file)
return file
def add_submission_result(self, submission=None, dataset=None, **kwargs):
"""Add a submission result."""
task = None
task = submission.task if submission is not None else task
task = dataset.task if dataset is not None else task
submission = submission \
if submission is not None else self.add_submission(task=task)
dataset = dataset \
if dataset is not None else self.add_dataset(task=task)
assert submission.task == dataset.task
args = {
"submission": submission,
"dataset": dataset,
}
args.update(kwargs)
submission_result = SubmissionResult(**args)
self.session.add(submission_result)
return submission_result
def add_executable(self, submission_result=None, **kwargs):
"""Create an executable and add it to the session"""
submission_result = submission_result \
if submission_result is not None \
else self.add_submission_result()
args = {
"submission_result": submission_result,
"digest": unique_digest(),
"filename": unique_unicode_id(),
}
args.update(kwargs)
executable = Executable(**args)
self.session.add(executable)
return executable
def add_evaluation(self, submission_result=None, testcase=None, **kwargs):
"""Add an evaluation."""
dataset = None
dataset = submission_result.dataset \
if submission_result is not None else dataset
dataset = testcase.dataset if testcase is not None else dataset
submission_result = submission_result \
if submission_result is not None \
else self.add_submission_result(dataset=dataset)
testcase = testcase if testcase is not None else self.add_testcase()
assert submission_result.dataset == testcase.dataset
args = {
"submission_result": submission_result,
"testcase": testcase,
}
args.update(kwargs)
evaluation = Evaluation(**args)
self.session.add(evaluation)
return evaluation
def add_user_test(self, task=None, participation=None, **kwargs):
"""Add a user test."""
if task is None:
task = self.add_task(contest=self.add_contest())
participation = participation \
if participation is not None \
else self.add_participation(contest=task.contest)
assert task.contest == participation.contest
args = {
"task": task,
"participation": participation,
"input": unique_digest(),
"timestamp": (task.contest.start + timedelta(0, unique_long_id())),
}
args.update(kwargs)
user_test = UserTest(**args)
self.session.add(user_test)
return user_test
def add_user_test_result(self, user_test=None, dataset=None, **kwargs):
"""Add a user test result."""
task = None
task = user_test.task if user_test is not None else task
task = dataset.task if dataset is not None else task
user_test = user_test \
if user_test is not None else self.add_user_test(task=task)
dataset = dataset \
if dataset is not None else self.add_dataset(task=task)
assert user_test.task == dataset.task
args = {
"user_test": user_test,
"dataset": dataset,
}
args.update(kwargs)
user_test_result = UserTestResult(**args)
self.session.add(user_test_result)
return user_test_result
# Other commonly used generation functions.
def add_submission_with_results(self, task, participation,
compilation_outcome=None):
"""Add a submission for the tasks, all of its results, and optionally
the compilation outcome for all results.
"""
submission = self.add_submission(task, participation)
results = [self.add_submission_result(submission, dataset)
for dataset in task.datasets]
if compilation_outcome is not None:
for result in results:
result.set_compilation_outcome(compilation_outcome)
return submission, results
def add_user_test_with_results(self, compilation_outcome=None):
"""Add a user_test for the first tasks, all of its results, and
optionally the compilation outcome for all results.
"""
user_test = self.add_user_test(self.tasks[0], self.participation)
results = [self.add_user_test_result(user_test, dataset)
for dataset in self.tasks[0].datasets]
if compilation_outcome is not None:
for result in results:
result.set_compilation_outcome(compilation_outcome)
return user_test, results
@staticmethod
def get_team(**kwargs):
"""Create a team"""
args = {
"code": unique_unicode_id(),
"name": unique_unicode_id(),
}
args.update(kwargs)
team = Team(**args)
return team
def add_team(self, **kwargs):
"""Create a team and add it to the session"""
team = self.get_team(**kwargs)
self.session.add(team)
return team
class DatabaseMixin(DatabaseObjectGeneratorMixin):
"""Mixin for tests with database access."""
@classmethod
def setUpClass(cls):
super(DatabaseMixin, cls).setUpClass()
assert "fortesting" in str(cms.db.engine), \
"Monkey patching of DB connection string failed"
drop_db()
init_db()
cls.connection = cms.db.engine.connect()
cms.db.metadata.create_all(cls.connection)
@classmethod
def tearDownClass(cls):
drop_db()
cls.connection.close()
cms.db.engine.dispose()
super(DatabaseMixin, cls).tearDownClass()
def setUp(self):
super(DatabaseMixin, self).setUp()
self.session = Session()
def tearDown(self):
self.session.rollback()
super(DatabaseMixin, self).tearDown()
def delete_data(self):
"""Delete all the data in the DB.
This is useful to call during tear down, for tests that rely on
starting from a clean DB.
"""
for table in itervalues(Base.metadata.tables):
self.session.execute(table.delete())
self.session.commit()
@staticmethod
def add_fsobject(digest, content):
dbbackend = DBBackend()
fobj = dbbackend.create_file(digest)
fobj.write(content)
dbbackend.commit_file(fobj, digest)
def add_contest(self, **kwargs):
"""Create a contest and add it to the session"""
contest = self.get_contest(**kwargs)
self.session.add(contest)
return contest
def add_announcement(self, **kwargs):
"""Create an announcement and add it to the session"""
announcement = self.get_announcement(**kwargs)
self.session.add(announcement)
return announcement
def add_user(self, **kwargs):
"""Create a user and add it to the session"""
user = self.get_user(**kwargs)
self.session.add(user)
return user
def add_participation(self, **kwargs):
"""Create a participation and add it to the session"""
participation = self.get_participation(**kwargs)
self.session.add(participation)
return participation
def add_message(self, **kwargs):
"""Create a message and add it to the session"""
message = self.get_message(**kwargs)
self.session.add(message)
return message
def add_question(self, **kwargs):
"""Create a question and add it to the session"""
question = self.get_question(**kwargs)
self.session.add(question)
return question
def add_task(self, **kwargs):
"""Create a task and add it to the session"""
task = self.get_task(**kwargs)
self.session.add(task)
return task
def add_statement(self, task=None, **kwargs):
"""Create a statement and add it to the session"""
task = task if task is not None else self.add_task()
args = {
"task": task,
"digest": unique_digest(),
"language": unique_unicode_id(),
}
args.update(kwargs)
statement = Statement(**args)
self.session.add(statement)
return statement
def add_dataset(self, **kwargs):
"""Create a dataset and add it to the session"""
dataset = self.get_dataset(**kwargs)
self.session.add(dataset)
return dataset
def add_manager(self, dataset=None, **kwargs):
"""Create a manager and add it to the session."""
manager = self.get_manager(dataset=dataset, **kwargs)
self.session.add(manager)
return manager
def add_testcase(self, dataset=None, **kwargs):
"""Add a testcase."""
dataset = dataset if dataset is not None else self.add_dataset()
args = {
"dataset": dataset,
"codename": unique_unicode_id(),
"input": unique_digest(),
"output": unique_digest(),
}
args.update(kwargs)
testcase = Testcase(**args)
self.session.add(testcase)
return testcase
def add_submission(self, task=None, participation=None, **kwargs):
"""Add a submission."""
submission = self.get_submission(task, participation, **kwargs)
self.session.add(submission)
return submission
def add_file(self, submission=None, **kwargs):
"""Create a file and add it to the session"""
if submission is None:
submission = self.add_submission()
args = {
"submission": submission,
"filename": unique_unicode_id(),
"digest": unique_digest(),
}
args.update(kwargs)
file_ = File(**args)
self.session.add(file_)
return file_
def add_token(self, submission=None, **kwargs):
"""Create a token and add it to the session"""
token = self.get_token(submission, **kwargs)
self.session.add(token)
return token
def add_submission_result(self, submission=None, dataset=None, **kwargs):
"""Add a submission result."""
submission_result = self.get_submission_result(submission, dataset,
**kwargs)
self.session.add(submission_result)
return submission_result
def add_executable(self, submission_result=None, **kwargs):
"""Create an executable and add it to the session"""
submission_result = submission_result \
if submission_result is not None \
else self.add_submission_result()
args = {
"submission_result": submission_result,
"digest": unique_digest(),
"filename": unique_unicode_id(),
}
args.update(kwargs)
executable = Executable(**args)
self.session.add(executable)
return executable
def add_evaluation(self, submission_result=None, testcase=None, **kwargs):
"""Add an evaluation."""
dataset = None
dataset = submission_result.dataset \
if submission_result is not None else dataset
dataset = testcase.dataset if testcase is not None else dataset
submission_result = submission_result \
if submission_result is not None \
else self.add_submission_result(dataset=dataset)
testcase = testcase if testcase is not None else self.add_testcase()
assert submission_result.dataset == testcase.dataset
args = {
"submission_result": submission_result,
"testcase": testcase,
}
args.update(kwargs)
evaluation = Evaluation(**args)
self.session.add(evaluation)
return evaluation
def add_user_test(self, task=None, participation=None, **kwargs):
"""Add a user test."""
if task is None:
task = self.add_task(contest=self.add_contest())
participation = participation \
if participation is not None \
else self.add_participation(contest=task.contest)
assert task.contest == participation.contest
args = {
"task": task,
"participation": participation,
"input": unique_digest(),
"timestamp": (task.contest.start + timedelta(0, unique_long_id())),
}
args.update(kwargs)
user_test = UserTest(**args)
self.session.add(user_test)
return user_test
def add_user_test_file(self, user_test=None, **kwargs):
"""Create a user test file and add it to the session"""
if user_test is None:
user_test = self.add_user_test()
args = {
"user_test": user_test,
"filename": unique_unicode_id(),
"digest": unique_digest(),
}
args.update(kwargs)
user_test_file = UserTestFile(**args)
self.session.add(user_test_file)
return user_test_file
def add_user_test_manager(self, user_test=None, **kwargs):
"""Create a user test manager and add it to the session"""
if user_test is None:
user_test = self.add_user_test()
args = {
"user_test": user_test,
"filename": unique_unicode_id(),
"digest": unique_digest(),
}
args.update(kwargs)
user_test_manager = UserTestManager(**args)
self.session.add(user_test_manager)
return user_test_manager
def add_user_test_result(self, user_test=None, dataset=None, **kwargs):
"""Add a user test result."""
task = None
task = user_test.task if user_test is not None else task
task = dataset.task if dataset is not None else task
user_test = user_test \
if user_test is not None else self.add_user_test(task=task)
dataset = dataset \
if dataset is not None else self.add_dataset(task=task)
assert user_test.task == dataset.task
args = {
"user_test": user_test,
"dataset": dataset,
}
args.update(kwargs)
user_test_result = UserTestResult(**args)
self.session.add(user_test_result)
return user_test_result
# Other commonly used generation functions.
def add_submission_with_results(self,
task,
participation,
compilation_outcome=None):
"""Add a submission for the tasks, all of its results, and optionally
the compilation outcome for all results.
"""
submission = self.add_submission(task, participation)
results = [
self.add_submission_result(submission, dataset)
for dataset in task.datasets
]
if compilation_outcome is not None:
for result in results:
result.set_compilation_outcome(compilation_outcome)
return submission, results
def add_user_test_with_results(self, compilation_outcome=None):
"""Add a user_test for the first tasks, all of its results, and
optionally the compilation outcome for all results.
"""
user_test = self.add_user_test(self.tasks[0], self.participation)
results = [
self.add_user_test_result(user_test, dataset)
for dataset in self.tasks[0].datasets
]
if compilation_outcome is not None:
for result in results:
result.set_compilation_outcome(compilation_outcome)
return user_test, results
def add_team(self, **kwargs):
"""Create a team and add it to the session"""
team = self.get_team(**kwargs)
self.session.add(team)
return team
class AddTestcaseHandler(BaseHandler):
"""Add a testcase to a dataset.
"""
@require_permission(BaseHandler.PERMISSION_ALL)
def get(self, dataset_id):
dataset = self.safe_get_item(Dataset, dataset_id)
task = dataset.task
self.r_params = self.render_params()
self.r_params["task"] = task
self.r_params["dataset"] = dataset
self.render("add_testcase.html", **self.r_params)
@require_permission(BaseHandler.PERMISSION_ALL)
def post(self, dataset_id):
fallback_page = "/dataset/%s/testcases/add" % dataset_id
dataset = self.safe_get_item(Dataset, dataset_id)
task = dataset.task
codename = self.get_argument("codename")
try:
input_ = self.request.files["input"][0]
output = self.request.files["output"][0]
except KeyError:
self.application.service.add_notification(
make_datetime(),
"Invalid data",
"Please fill both input and output.")
self.redirect(fallback_page)
return
public = self.get_argument("public", None) is not None
task_name = task.name
self.sql_session.close()
try:
input_digest = \
self.application.service.file_cacher.put_file_content(
input_["body"],
"Testcase input for task %s" % task_name)
output_digest = \
self.application.service.file_cacher.put_file_content(
output["body"],
"Testcase output for task %s" % task_name)
except Exception as error:
self.application.service.add_notification(
make_datetime(),
"Testcase storage failed",
repr(error))
self.redirect(fallback_page)
return
self.sql_session = Session()
dataset = self.safe_get_item(Dataset, dataset_id)
task = dataset.task
testcase = Testcase(
codename, public, input_digest, output_digest, dataset=dataset)
self.sql_session.add(testcase)
if self.try_commit():
# max_score and/or extra_headers might have changed.
self.application.service.proxy_service.reinitialize()
self.redirect("/task/%s" % task.id)
else:
self.redirect(fallback_page)
class AddTestcasesHandler(BaseHandler):
"""Add several testcases to a dataset.
"""
@require_permission(BaseHandler.PERMISSION_ALL)
def get(self, dataset_id):
dataset = self.safe_get_item(Dataset, dataset_id)
task = dataset.task
self.r_params = self.render_params()
self.r_params["task"] = task
self.r_params["dataset"] = dataset
self.render("add_testcases.html", **self.r_params)
@require_permission(BaseHandler.PERMISSION_ALL)
def post(self, dataset_id):
fallback_page = "/dataset/%s/testcases/add_multiple" % dataset_id
# TODO: this method is quite long, some splitting is needed.
dataset = self.safe_get_item(Dataset, dataset_id)
task = dataset.task
try:
archive = self.request.files["archive"][0]
except KeyError:
self.application.service.add_notification(
make_datetime(),
"Invalid data",
"Please choose tests archive.")
self.redirect(fallback_page)
return
public = self.get_argument("public", None) is not None
overwrite = self.get_argument("overwrite", None) is not None
# Get input/output file names templates, or use default ones.
input_template = self.get_argument("input_template", "input.*")
output_template = self.get_argument("output_template", "output.*")
input_re = re.compile(re.escape(input_template).replace("\\*",
"(.*)") + "$")
output_re = re.compile(re.escape(output_template).replace("\\*",
"(.*)") + "$")
task_name = task.name
self.sql_session.close()
fp = StringIO(archive["body"])
try:
with zipfile.ZipFile(fp, "r") as archive_zfp:
tests = dict()
# Match input/output file names to testcases' codenames.
for filename in archive_zfp.namelist():
match = input_re.match(filename)
if match:
codename = match.group(1)
if codename not in tests:
tests[codename] = [None, None]
tests[codename][0] = filename
else:
match = output_re.match(filename)
if match:
codename = match.group(1)
if codename not in tests:
tests[codename] = [None, None]
tests[codename][1] = filename
skipped_tc = []
overwritten_tc = []
added_tc = []
for codename, testdata in tests.iteritems():
# If input or output file isn't found, skip it.
if not testdata[0] or not testdata[1]:
continue
self.sql_session = Session()
# Check, whether current testcase already exists.
dataset = self.safe_get_item(Dataset, dataset_id)
task = dataset.task
if codename in dataset.testcases:
# If we are allowed, remove existing testcase.
# If not - skip this testcase.
if overwrite:
testcase = dataset.testcases[codename]
self.sql_session.delete(testcase)
if not self.try_commit():
skipped_tc.append(codename)
continue
overwritten_tc.append(codename)
else:
skipped_tc.append(codename)
continue
# Add current testcase.
try:
input_ = archive_zfp.read(testdata[0])
output = archive_zfp.read(testdata[1])
except Exception as error:
self.application.service.add_notification(
make_datetime(),
"Reading testcase %s failed" % codename,
repr(error))
self.redirect(fallback_page)
return
try:
input_digest = self.application.service\
.file_cacher.put_file_content(
input_,
"Testcase input for task %s" % task_name)
output_digest = self.application.service\
.file_cacher.put_file_content(
output,
"Testcase output for task %s" % task_name)
except Exception as error:
self.application.service.add_notification(
make_datetime(),
"Testcase storage failed",
repr(error))
self.redirect(fallback_page)
return
testcase = Testcase(codename, public, input_digest,
output_digest, dataset=dataset)
self.sql_session.add(testcase)
if not self.try_commit():
self.application.service.add_notification(
make_datetime(),
"Couldn't add test %s" % codename,
"")
self.redirect(fallback_page)
return
if codename not in overwritten_tc:
added_tc.append(codename)
except zipfile.BadZipfile:
self.application.service.add_notification(
make_datetime(),
"The selected file is not a zip file.",
"Please select a valid zip file.")
self.redirect(fallback_page)
return
self.application.service.add_notification(
make_datetime(),
"Successfully added %d and overwritten %d testcase(s)" %
(len(added_tc), len(overwritten_tc)),
"Added: %s; overwritten: %s; skipped: %s" %
(", ".join(added_tc) if added_tc else "none",
", ".join(overwritten_tc) if overwritten_tc else "none",
", ".join(skipped_tc) if skipped_tc else "none"))
self.application.service.proxy_service.reinitialize()
self.redirect("/task/%s" % task.id)
class DatabaseMixin(DatabaseObjectGeneratorMixin):
"""Mixin for tests with database access."""
@classmethod
def setUpClass(cls):
super(DatabaseMixin, cls).setUpClass()
assert "fortesting" in str(engine), \
"Monkey patching of DB connection string failed"
drop_db()
init_db()
@classmethod
def tearDownClass(cls):
drop_db()
super(DatabaseMixin, cls).tearDownClass()
def setUp(self):
super(DatabaseMixin, self).setUp()
self.session = Session()
def tearDown(self):
self.session.rollback()
super(DatabaseMixin, self).tearDown()
def delete_data(self):
"""Delete all the data in the DB.
This is useful to call during tear down, for tests that rely on
starting from a clean DB.
"""
for table in itervalues(metadata.tables):
self.session.execute(table.delete())
self.session.commit()
@staticmethod
def add_fsobject(digest, content):
dbbackend = DBBackend()
fobj = dbbackend.create_file(digest)
fobj.write(content)
dbbackend.commit_file(fobj, digest)
def add_contest(self, **kwargs):
"""Create a contest and add it to the session"""
contest = self.get_contest(**kwargs)
self.session.add(contest)
return contest
def add_announcement(self, **kwargs):
"""Create an announcement and add it to the session"""
announcement = self.get_announcement(**kwargs)
self.session.add(announcement)
return announcement
def add_user(self, **kwargs):
"""Create a user and add it to the session"""
user = self.get_user(**kwargs)
self.session.add(user)
return user
def add_participation(self, **kwargs):
"""Create a participation and add it to the session"""
participation = self.get_participation(**kwargs)
self.session.add(participation)
return participation
def add_message(self, **kwargs):
"""Create a message and add it to the session"""
message = self.get_message(**kwargs)
self.session.add(message)
return message
def add_question(self, **kwargs):
"""Create a question and add it to the session"""
question = self.get_question(**kwargs)
self.session.add(question)
return question
def add_task(self, **kwargs):
"""Create a task and add it to the session"""
task = self.get_task(**kwargs)
self.session.add(task)
return task
def add_statement(self, task=None, **kwargs):
"""Create a statement and add it to the session"""
task = task if task is not None else self.add_task()
args = {
"task": task,
"digest": unique_digest(),
"language": unique_unicode_id(),
}
args.update(kwargs)
statement = Statement(**args)
self.session.add(statement)
return statement
def add_dataset(self, **kwargs):
"""Create a dataset and add it to the session"""
dataset = self.get_dataset(**kwargs)
self.session.add(dataset)
return dataset
def add_manager(self, dataset=None, **kwargs):
"""Create a manager and add it to the session."""
manager = self.get_manager(dataset=dataset, **kwargs)
self.session.add(manager)
return manager
def add_testcase(self, dataset=None, **kwargs):
"""Add a testcase."""
dataset = dataset if dataset is not None else self.add_dataset()
args = {
"dataset": dataset,
"codename": unique_unicode_id(),
"input": unique_digest(),
"output": unique_digest(),
}
args.update(kwargs)
testcase = Testcase(**args)
self.session.add(testcase)
return testcase
def add_submission(self, task=None, participation=None, **kwargs):
"""Add a submission."""
submission = self.get_submission(task, participation, **kwargs)
self.session.add(submission)
return submission
def add_file(self, submission=None, **kwargs):
"""Create a file and add it to the session"""
if submission is None:
submission = self.add_submission()
args = {
"submission": submission,
"filename": unique_unicode_id(),
"digest": unique_digest(),
}
args.update(kwargs)
file_ = File(**args)
self.session.add(file_)
return file_
def add_token(self, submission=None, **kwargs):
"""Create a token and add it to the session"""
token = self.get_token(submission, **kwargs)
self.session.add(token)
return token
def add_submission_result(self, submission=None, dataset=None, **kwargs):
"""Add a submission result."""
submission_result = self.get_submission_result(
submission, dataset, **kwargs)
self.session.add(submission_result)
return submission_result
def add_executable(self, submission_result=None, **kwargs):
"""Create an executable and add it to the session"""
submission_result = submission_result \
if submission_result is not None \
else self.add_submission_result()
args = {
"submission_result": submission_result,
"digest": unique_digest(),
"filename": unique_unicode_id(),
}
args.update(kwargs)
executable = Executable(**args)
self.session.add(executable)
return executable
def add_evaluation(self, submission_result=None, testcase=None, **kwargs):
"""Add an evaluation."""
dataset = None
dataset = submission_result.dataset \
if submission_result is not None else dataset
dataset = testcase.dataset if testcase is not None else dataset
submission_result = submission_result \
if submission_result is not None \
else self.add_submission_result(dataset=dataset)
testcase = testcase if testcase is not None else self.add_testcase()
assert submission_result.dataset == testcase.dataset
args = {
"submission_result": submission_result,
"testcase": testcase,
}
args.update(kwargs)
evaluation = Evaluation(**args)
self.session.add(evaluation)
return evaluation
def add_user_test(self, task=None, participation=None, **kwargs):
"""Add a user test."""
if task is None:
task = self.add_task(contest=self.add_contest())
participation = participation \
if participation is not None \
else self.add_participation(contest=task.contest)
assert task.contest == participation.contest
args = {
"task": task,
"participation": participation,
"input": unique_digest(),
"timestamp": (task.contest.start + timedelta(0, unique_long_id())),
}
args.update(kwargs)
user_test = UserTest(**args)
self.session.add(user_test)
return user_test
def add_user_test_file(self, user_test=None, **kwargs):
"""Create a user test file and add it to the session"""
if user_test is None:
user_test = self.add_user_test()
args = {
"user_test": user_test,
"filename": unique_unicode_id(),
"digest": unique_digest(),
}
args.update(kwargs)
user_test_file = UserTestFile(**args)
self.session.add(user_test_file)
return user_test_file
def add_user_test_manager(self, user_test=None, **kwargs):
"""Create a user test manager and add it to the session"""
if user_test is None:
user_test = self.add_user_test()
args = {
"user_test": user_test,
"filename": unique_unicode_id(),
"digest": unique_digest(),
}
args.update(kwargs)
user_test_manager = UserTestManager(**args)
self.session.add(user_test_manager)
return user_test_manager
def add_user_test_result(self, user_test=None, dataset=None, **kwargs):
"""Add a user test result."""
task = None
task = user_test.task if user_test is not None else task
task = dataset.task if dataset is not None else task
user_test = user_test \
if user_test is not None else self.add_user_test(task=task)
dataset = dataset \
if dataset is not None else self.add_dataset(task=task)
assert user_test.task == dataset.task
args = {
"user_test": user_test,
"dataset": dataset,
}
args.update(kwargs)
user_test_result = UserTestResult(**args)
self.session.add(user_test_result)
return user_test_result
# Other commonly used generation functions.
def add_submission_with_results(self, task, participation,
compilation_outcome=None):
"""Add a submission for the tasks, all of its results, and optionally
the compilation outcome for all results.
"""
submission = self.add_submission(task, participation)
results = [self.add_submission_result(submission, dataset)
for dataset in task.datasets]
if compilation_outcome is not None:
for result in results:
result.set_compilation_outcome(compilation_outcome)
return submission, results
def add_user_test_with_results(self, compilation_outcome=None):
"""Add a user_test for the first tasks, all of its results, and
optionally the compilation outcome for all results.
"""
user_test = self.add_user_test(self.tasks[0], self.participation)
results = [self.add_user_test_result(user_test, dataset)
for dataset in self.tasks[0].datasets]
if compilation_outcome is not None:
for result in results:
result.set_compilation_outcome(compilation_outcome)
return user_test, results
def add_team(self, **kwargs):
"""Create a team and add it to the session"""
team = self.get_team(**kwargs)
self.session.add(team)
return team
class TestCaseWithDatabase(unittest.TestCase):
"""TestCase subclass starting with a clean testing database."""
@classmethod
def setUpClass(cls):
assert "fortesting" in str(cms.db.engine), \
"Monkey patching of DB connection string failed"
drop_db()
init_db()
cls.connection = cms.db.engine.connect()
cms.db.metadata.create_all(cls.connection)
@classmethod
def tearDownClass(cls):
drop_db()
cls.connection.close()
cms.db.engine.dispose()
def setUp(self):
self.session = Session()
def tearDown(self):
self.session.rollback()
def delete_data(self):
"""Delete all the data in the DB.
This is useful to call during tear down, for tests that rely on
starting from a clean DB.
"""
for table in itervalues(Base.metadata.tables):
self.session.execute(table.delete())
self.session.commit()
@staticmethod
def add_fsobject(digest, content):
dbbackend = DBBackend()
fobj = dbbackend.create_file(digest)
fobj.write(content)
dbbackend.commit_file(fobj, digest)
@staticmethod
def get_contest(**kwargs):
"""Create a contest"""
args = {
"name": unique_unicode_id(),
"description": unique_unicode_id(),
}
args.update(kwargs)
contest = Contest(**args)
return contest
def add_contest(self, **kwargs):
"""Create a contest and add it to the session"""
contest = self.get_contest(**kwargs)
self.session.add(contest)
return contest
@staticmethod
def get_user(**kwargs):
"""Create a user"""
args = {
"username": unique_unicode_id(),
"password": "",
"first_name": unique_unicode_id(),
"last_name": unique_unicode_id(),
}
args.update(kwargs)
user = User(**args)
return user
def add_user(self, **kwargs):
"""Create a user and add it to the session"""
user = self.get_user(**kwargs)
self.session.add(user)
return user
@staticmethod
def get_participation(user=None, contest=None, **kwargs):
"""Create a participation"""
user = user if user is not None else TestCaseWithDatabase.get_user()
contest = contest \
if contest is not None else TestCaseWithDatabase.get_contest()
args = {
"user": user,
"contest": contest,
}
args.update(kwargs)
participation = Participation(**args)
return participation
def add_participation(self, **kwargs):
"""Create a participation and add it to the session"""
participation = self.get_participation(**kwargs)
self.session.add(participation)
return participation
@staticmethod
def get_task(**kwargs):
"""Create a task"""
args = {
"name": unique_unicode_id(),
"title": unique_unicode_id(),
}
args.update(kwargs)
task = Task(**args)
return task
def add_task(self, **kwargs):
"""Create a task and add it to the session"""
task = self.get_task(**kwargs)
self.session.add(task)
return task
def add_statement(self, task=None, **kwargs):
"""Create a statement and add it to the session"""
task = task if task is not None else self.add_task()
args = {
"task": task,
"digest": unique_digest(),
"language": unique_unicode_id(),
}
args.update(kwargs)
statement = Statement(**args)
self.session.add(statement)
return statement
@staticmethod
def get_dataset(task=None, **kwargs):
"""Create a dataset"""
task = task if task is not None else TestCaseWithDatabase.get_task()
args = {
"task": task,
"description": unique_unicode_id(),
"task_type": "",
# "None" won't work here as the column is defined as non
# nullable. As soon as we'll depend on SQLAlchemy 1.1 we
# will be able to put JSON.NULL here instead.
"task_type_parameters": {},
"score_type": "",
# Same here.
"score_type_parameters": {},
}
args.update(kwargs)
dataset = Dataset(**args)
return dataset
def add_dataset(self, **kwargs):
"""Create a dataset and add it to the session"""
dataset = self.get_dataset(**kwargs)
self.session.add(dataset)
return dataset
def add_testcase(self, dataset=None, **kwargs):
"""Add a testcase."""
dataset = dataset if dataset is not None else self.add_dataset()
args = {
"dataset": dataset,
"codename": unique_unicode_id(),
"input": unique_digest(),
"output": unique_digest(),
}
args.update(kwargs)
testcase = Testcase(**args)
self.session.add(testcase)
return testcase
def add_submission(self, task=None, participation=None, **kwargs):
"""Add a submission."""
if task is None:
task = self.add_task(contest=self.add_contest())
participation = participation \
if participation is not None \
else self.add_participation(contest=task.contest)
assert task.contest == participation.contest
args = {
"task": task,
"participation": participation,
"timestamp": (task.contest.start + timedelta(0, unique_long_id())),
}
args.update(kwargs)
submission = Submission(**args)
self.session.add(submission)
return submission
def add_file(self, submission=None, **kwargs):
"""Create a file and add it to the session"""
if submission is None:
submission = self.add_sbubmission()
args = {
"submission": submission,
"filename": unique_unicode_id(),
"digest": unique_digest(),
}
args.update(kwargs)
file = File(**args)
self.session.add(file)
return file
def add_submission_result(self, submission=None, dataset=None, **kwargs):
"""Add a submission result."""
task = None
task = submission.task if submission is not None else task
task = dataset.task if dataset is not None else task
submission = submission \
if submission is not None else self.add_submission(task=task)
dataset = dataset \
if dataset is not None else self.add_dataset(task=task)
assert submission.task == dataset.task
args = {
"submission": submission,
"dataset": dataset,
}
args.update(kwargs)
submission_result = SubmissionResult(**args)
self.session.add(submission_result)
return submission_result
def add_executable(self, submission_result=None, **kwargs):
"""Create an executable and add it to the session"""
submission_result = submission_result \
if submission_result is not None \
else self.add_submission_result()
args = {
"submission_result": submission_result,
"digest": unique_digest(),
"filename": unique_unicode_id(),
}
args.update(kwargs)
executable = Executable(**args)
self.session.add(executable)
return executable
def add_evaluation(self, submission_result=None, testcase=None, **kwargs):
"""Add an evaluation."""
dataset = None
dataset = submission_result.dataset \
if submission_result is not None else dataset
dataset = testcase.dataset if testcase is not None else dataset
submission_result = submission_result \
if submission_result is not None \
else self.add_submission_result(dataset=dataset)
testcase = testcase if testcase is not None else self.add_testcase()
assert submission_result.dataset == testcase.dataset
args = {
"submission_result": submission_result,
"testcase": testcase,
}
args.update(kwargs)
evaluation = Evaluation(**args)
self.session.add(evaluation)
return evaluation
def add_user_test(self, task=None, participation=None, **kwargs):
"""Add a user test."""
if task is None:
task = self.add_task(contest=self.add_contest())
participation = participation \
if participation is not None \
else self.add_participation(contest=task.contest)
assert task.contest == participation.contest
args = {
"task": task,
"participation": participation,
"input": unique_digest(),
"timestamp": (task.contest.start + timedelta(0, unique_long_id())),
}
args.update(kwargs)
user_test = UserTest(**args)
self.session.add(user_test)
return user_test
def add_user_test_result(self, user_test=None, dataset=None, **kwargs):
"""Add a user test result."""
task = None
task = user_test.task if user_test is not None else task
task = dataset.task if dataset is not None else task
user_test = user_test \
if user_test is not None else self.add_user_test(task=task)
dataset = dataset \
if dataset is not None else self.add_dataset(task=task)
assert user_test.task == dataset.task
args = {
"user_test": user_test,
"dataset": dataset,
}
args.update(kwargs)
user_test_result = UserTestResult(**args)
self.session.add(user_test_result)
return user_test_result
# Other commonly used generation functions.
def add_submission_with_results(self,
task,
participation,
compilation_outcome=None):
"""Add a submission for the tasks, all of its results, and optionally
the compilation outcome for all results.
"""
submission = self.add_submission(task, participation)
results = [
self.add_submission_result(submission, dataset)
for dataset in task.datasets
]
if compilation_outcome is not None:
for result in results:
result.set_compilation_outcome(compilation_outcome)
return submission, results
def add_user_test_with_results(self, compilation_outcome=None):
"""Add a user_test for the first tasks, all of its results, and
optionally the compilation outcome for all results.
"""
user_test = self.add_user_test(self.tasks[0], self.participation)
results = [
self.add_user_test_result(user_test, dataset)
for dataset in self.tasks[0].datasets
]
if compilation_outcome is not None:
for result in results:
result.set_compilation_outcome(compilation_outcome)
return user_test, results
@staticmethod
def get_team(**kwargs):
"""Create a team"""
args = {
"code": unique_unicode_id(),
"name": unique_unicode_id(),
}
args.update(kwargs)
team = Team(**args)
return team
def add_team(self, **kwargs):
"""Create a team and add it to the session"""
team = self.get_team(**kwargs)
self.session.add(team)
return team
class TestCaseWithDatabase(unittest.TestCase):
"""TestCase subclass starting with a clean testing database."""
@classmethod
def setUpClass(cls):
cms.db.engine = create_engine(cms.config.database)
drop_db()
init_db()
cls.connection = cms.db.engine.connect()
cms.db.metadata.create_all(cls.connection)
@classmethod
def tearDownClass(cls):
drop_db()
cls.connection.close()
cms.db.engine.dispose()
def setUp(self):
self.session = Session()
def tearDown(self):
self.session.rollback()
def add_contest(self, **kwargs):
"""Add a contest."""
args = {
"name": unique_unicode_id(),
"description": unique_unicode_id(),
}
args.update(kwargs)
contest = Contest(**args)
self.session.add(contest)
return contest
def add_user(self, **kwargs):
"""Add a user."""
args = {
"username": unique_unicode_id(),
"password": "",
"first_name": unique_unicode_id(),
"last_name": unique_unicode_id(),
}
args.update(kwargs)
user = User(**args)
self.session.add(user)
return user
def add_participation(self, user=None, contest=None, **kwargs):
"""Add a participation."""
user = user if user is not None else self.add_user()
contest = contest if contest is not None else self.add_contest()
args = {
"user": user,
"contest": contest,
}
args.update(kwargs)
participation = Participation(**args)
self.session.add(participation)
return participation
def add_task(self, contest=None, **kwargs):
"""Add a task."""
contest = contest if contest is not None else self.add_contest()
args = {
"contest": contest,
"name": unique_unicode_id(),
"title": unique_unicode_id(),
}
args.update(kwargs)
task = Task(**args)
self.session.add(task)
return task
def add_dataset(self, task=None, **kwargs):
"""Add a dataset."""
task = task if task is not None else self.add_task()
args = {
"task": task,
"description": unique_unicode_id(),
"task_type": "",
"task_type_parameters": "",
"score_type": "",
"score_type_parameters": "",
}
args.update(kwargs)
dataset = Dataset(**args)
self.session.add(dataset)
return dataset
def add_testcase(self, dataset=None, **kwargs):
"""Add a testcase."""
dataset = dataset if dataset is not None else self.add_dataset()
args = {
"dataset": dataset,
"codename": unique_unicode_id(),
"input": unique_digest(),
"output": unique_digest(),
}
args.update(kwargs)
testcase = Testcase(**args)
self.session.add(testcase)
return testcase
def add_submission(self, task=None, participation=None, **kwargs):
"""Add a submission."""
task = task if task is not None else self.add_task()
participation = participation \
if participation is not None \
else self.add_participation(contest=task.contest)
assert task.contest == participation.contest
args = {
"task": task,
"participation": participation,
"timestamp": (task.contest.start + timedelta(0, unique_long_id())),
}
args.update(kwargs)
submission = Submission(**args)
self.session.add(submission)
return submission
def add_submission_result(self, submission=None, dataset=None, **kwargs):
"""Add a submission result."""
task = None
task = submission.task if submission is not None else task
task = dataset.task if dataset is not None else task
submission = submission \
if submission is not None else self.add_submission(task=task)
dataset = dataset \
if dataset is not None else self.add_dataset(task=task)
assert submission.task == dataset.task
args = {
"submission": submission,
"dataset": dataset,
}
args.update(kwargs)
submission_result = SubmissionResult(**args)
self.session.add(submission_result)
return submission_result
def add_evaluation(self, submission_result=None, testcase=None, **kwargs):
"""Add an evaluation."""
dataset = None
dataset = submission_result.dataset \
if submission_result is not None else dataset
dataset = testcase.dataset if testcase is not None else dataset
submission_result = submission_result \
if submission_result is not None else self.add_submission_result()
testcase = testcase if testcase is not None else self.add_testcase()
assert submission_result.dataset == testcase.dataset
args = {
"submission_result": submission_result,
"testcase": testcase,
}
args.update(kwargs)
evaluation = Evaluation(**args)
self.session.add(evaluation)
return evaluation
def add_user_test(self, task=None, participation=None, **kwargs):
"""Add a user test."""
task = task if task is not None else self.add_task()
participation = participation \
if participation is not None \
else self.add_participation(contest=task.contest)
assert task.contest == participation.contest
args = {
"task": task,
"participation": participation,
"input": unique_digest(),
"timestamp": (task.contest.start + timedelta(0, unique_long_id())),
}
args.update(kwargs)
user_test = UserTest(**args)
self.session.add(user_test)
return user_test
def add_user_test_result(self, user_test=None, dataset=None, **kwargs):
"""Add a user test result."""
task = None
task = user_test.task if user_test is not None else task
task = dataset.task if dataset is not None else task
user_test = user_test \
if user_test is not None else self.add_user_test(task=task)
dataset = dataset \
if dataset is not None else self.add_dataset(task=task)
assert user_test.task == dataset.task
args = {
"user_test": user_test,
"dataset": dataset,
}
args.update(kwargs)
user_test_result = UserTestResult(**args)
self.session.add(user_test_result)
return user_test_result
# Other commonly used generation functions.
def add_submission_with_results(self, task, participation,
compilation_outcome=None):
"""Add a submission for the tasks, all of its results, and optionally
the compilation outcome for all results.
"""
submission = self.add_submission(task, participation)
results = [self.add_submission_result(submission, dataset)
for dataset in task.datasets]
if compilation_outcome is not None:
for result in results:
result.set_compilation_outcome(compilation_outcome)
return submission, results
def add_user_test_with_results(self, compilation_outcome=None):
"""Add a user_test for the first tasks, all of its results, and
optionally the compilation outcome for all results.
"""
user_test = self.add_user_test(self.tasks[0], self.participation)
results = [self.add_user_test_result(user_test, dataset)
for dataset in self.tasks[0].datasets]
if compilation_outcome is not None:
for result in results:
result.set_compilation_outcome(compilation_outcome)
return user_test, results
def test_asso_chufang_bingren(self):
from cms.db.orm import ChuFang,DanWei,\
BingRen,DiZhi,YiSheng,ChuFang_BingRen_Asso,YaoWei,YaoXing,JingLuo,Yao,Yao_ChuFang_Asso
dizhi = DiZhi("中国", "湖南", "湘潭市", "湘潭县云湖桥镇北岸村道林组83号")
bingren = BingRen('张三', 1, date(2015, 4, 2), '13673265899')
bingren.dizhi = dizhi
dizhi2 = DiZhi("中国", "湖北", "十堰市", "茅箭区施洋路83号")
danwei = DanWei("任之堂")
yisheng = YiSheng('余浩', 1, date(2015, 4, 2), '13673265859')
danwei.yishengs = [yisheng]
danwei.dizhi = dizhi2
yaowei = YaoWei("酸")
yaoxing = YaoXing("寒")
jingluo = JingLuo("足厥阴肝经")
yao = Yao("白芍")
chufang = ChuFang("桂枝汤")
yao.yaowei = yaowei
yao.yaoxing = yaoxing
yao.guijing = [jingluo]
yao_chufang = Yao_ChuFang_Asso(yao, chufang, 7, "加热稀粥")
chufang_bingren = ChuFang_BingRen_Asso(bingren, chufang,
datetime.now())
# many to many association table don't add to session
# Session.add(Yao_ChuFang_Asso)
# Session.add(ChuFang_BingRen_Asso)
Session.add(yaowei)
Session.add(yaoxing)
Session.add(jingluo)
Session.add(yao)
Session.add(chufang)
Session.add(yao_chufang)
Session.add(dizhi)
Session.add(bingren)
Session.add(dizhi2)
Session.add(danwei)
Session.add(yisheng)
Session.add(chufang_bingren)
Session.commit()
items = Session.query(BingRen).filter(
BingRen.dianhua == "13673265899").first()
self.assertEqual(items.dizhi.jiedao, u"湘潭县云湖桥镇北岸村道林组83号")
items = Session.query(BingRen).join(DiZhi).filter(
DiZhi.sheng == "湖南").first()
self.assertEqual(items.dizhi.jiedao, u"湘潭县云湖桥镇北岸村道林组83号")
items = Session.query(Yao).all()
items.extend(Session.query(YaoXing).all())
items.extend(Session.query(YaoWei).all())
items.extend(Session.query(JingLuo).all())
items.extend(Session.query(ChuFang).all())
items.extend(Session.query(BingRen).all())
items.extend(Session.query(YiSheng).all())
items.extend(Session.query(DanWei).all())
items.extend(Session.query(DiZhi).all())
for m in items:
Session.delete(m)
Session.commit()
class AddTestcasesHandler(BaseHandler):
"""Add several testcases to a dataset.
"""
def get(self, dataset_id):
dataset = self.safe_get_item(Dataset, dataset_id)
task = dataset.task
self.r_params = self.render_params()
self.r_params["task"] = task
self.r_params["dataset"] = dataset
self.render("add_testcases.html", **self.r_params)
def post(self, dataset_id):
fallback_page = "/dataset/%s/testcases/add_multiple" % dataset_id
# TODO: this method is quite long, some splitting is needed.
dataset = self.safe_get_item(Dataset, dataset_id)
task = dataset.task
try:
archive = self.request.files["archive"][0]
except KeyError:
self.application.service.add_notification(
make_datetime(), "Invalid data",
"Please choose tests archive.")
self.redirect(fallback_page)
return
public = self.get_argument("public", None) is not None
overwrite = self.get_argument("overwrite", None) is not None
# Get input/output file names templates, or use default ones.
input_template = self.get_argument("input_template", None)
if not input_template:
input_template = "input.*"
output_template = self.get_argument("output_template", None)
if not output_template:
output_template = "output.*"
input_re = re.compile(
re.escape(input_template).replace("\\*", "(.*)") + "$")
output_re = re.compile(
re.escape(output_template).replace("\\*", "(.*)") + "$")
task_name = task.name
self.sql_session.close()
fp = StringIO(archive["body"])
try:
with zipfile.ZipFile(fp, "r") as archive_zfp:
tests = dict()
# Match input/output file names to testcases' codenames.
for filename in archive_zfp.namelist():
match = input_re.match(filename)
if match:
codename = match.group(1)
if codename not in tests:
tests[codename] = [None, None]
tests[codename][0] = filename
else:
match = output_re.match(filename)
if match:
codename = match.group(1)
if codename not in tests:
tests[codename] = [None, None]
tests[codename][1] = filename
skipped_tc = []
overwritten_tc = []
added_tc = []
for codename, testdata in tests.iteritems():
# If input or output file isn't found, skip it.
if not testdata[0] or not testdata[1]:
continue
self.sql_session = Session()
# Check, whether current testcase already exists.
dataset = self.safe_get_item(Dataset, dataset_id)
task = dataset.task
if codename in dataset.testcases:
# If we are allowed, remove existing testcase.
# If not - skip this testcase.
if overwrite:
testcase = dataset.testcases[codename]
self.sql_session.delete(testcase)
if not self.try_commit():
skipped_tc.append(codename)
continue
overwritten_tc.append(codename)
else:
skipped_tc.append(codename)
continue
# Add current testcase.
try:
input_ = archive_zfp.read(testdata[0])
output = archive_zfp.read(testdata[1])
except Exception as error:
self.application.service.add_notification(
make_datetime(),
"Reading testcase %s failed" % codename,
repr(error))
self.redirect(fallback_page)
return
try:
input_digest = self.application.service\
.file_cacher.put_file_content(
input_,
"Testcase input for task %s" % task_name)
output_digest = self.application.service\
.file_cacher.put_file_content(
output,
"Testcase output for task %s" % task_name)
except Exception as error:
self.application.service.add_notification(
make_datetime(), "Testcase storage failed",
repr(error))
self.redirect(fallback_page)
return
testcase = Testcase(codename,
public,
input_digest,
output_digest,
dataset=dataset)
self.sql_session.add(testcase)
if not self.try_commit():
self.application.service.add_notification(
make_datetime(), "Couldn't add test %s" % codename,
"")
self.redirect(fallback_page)
return
if codename not in overwritten_tc:
added_tc.append(codename)
except zipfile.BadZipfile:
self.application.service.add_notification(
make_datetime(), "The selected file is not a zip file.",
"Please select a valid zip file.")
self.redirect(fallback_page)
return
self.application.service.add_notification(
make_datetime(),
"Successfully added %d and overwritten %d testcase(s)" %
(len(added_tc), len(overwritten_tc)),
"Added: %s; overwritten: %s; skipped: %s" %
(", ".join(added_tc) if added_tc else "none",
", ".join(overwritten_tc) if overwritten_tc else "none",
", ".join(skipped_tc) if skipped_tc else "none"))
self.application.service.proxy_service.reinitialize()
self.redirect("/task/%s" % task.id)
class AddTestcaseHandler(BaseHandler):
"""Add a testcase to a dataset.
"""
@require_permission(BaseHandler.PERMISSION_ALL)
def get(self, dataset_id):
dataset = self.safe_get_item(Dataset, dataset_id)
task = dataset.task
self.r_params = self.render_params()
self.r_params["task"] = task
self.r_params["dataset"] = dataset
self.render("add_testcase.html", **self.r_params)
@require_permission(BaseHandler.PERMISSION_ALL)
def post(self, dataset_id):
fallback_page = self.url("dataset", dataset_id, "testcases", "add")
dataset = self.safe_get_item(Dataset, dataset_id)
task = dataset.task
codename = self.get_argument("codename")
try:
input_ = self.request.files["input"][0]
output = self.request.files["output"][0]
except KeyError:
self.application.service.add_notification(
make_datetime(), "Invalid data",
"Please fill both input and output.")
self.redirect(fallback_page)
return
public = self.get_argument("public", None) is not None
task_name = task.name
self.sql_session.close()
try:
input_digest = \
self.application.service.file_cacher.put_file_content(
input_["body"],
"Testcase input for task %s" % task_name)
output_digest = \
self.application.service.file_cacher.put_file_content(
output["body"],
"Testcase output for task %s" % task_name)
except Exception as error:
self.application.service.add_notification(
make_datetime(), "Testcase storage failed", repr(error))
self.redirect(fallback_page)
return
self.sql_session = Session()
dataset = self.safe_get_item(Dataset, dataset_id)
task = dataset.task
testcase = Testcase(codename,
public,
input_digest,
output_digest,
dataset=dataset)
self.sql_session.add(testcase)
if self.try_commit():
# max_score and/or extra_headers might have changed.
self.application.service.proxy_service.reinitialize()
self.redirect(self.url("task", task.id))
else:
self.redirect(fallback_page)
def test_all_tables(self):
from cms.db.orm import ChuFang,DanWei,\
BingRen,DiZhi,YiSheng,ChuFang_BingRen_Asso,YaoWei,YaoXing,JingLuo,Yao,Yao_ChuFang_Asso
dizhi = DiZhi("中国", "湖南", "湘潭市", "湘潭县云湖桥镇北岸村道林组83号")
bingren = BingRen('张三', 1, date(2015, 4, 2), '13673265899')
bingren.dizhi = dizhi
dizhi2 = DiZhi("中国", "湖北", "十堰市", "茅箭区施洋路83号")
danwei = DanWei("任之堂")
yisheng = YiSheng('余浩', 1, date(2015, 4, 2), '13673265859')
danwei.yishengs = [yisheng]
danwei.dizhi = dizhi2
yaowei = YaoWei("酸")
yaoxing = YaoXing("寒")
jingluo = JingLuo("足厥阴肝经")
yao = Yao("白芍")
yaowei2 = YaoWei("甘")
yaoxing2 = YaoXing("温")
jingluo2 = JingLuo("足太阴脾经")
yao2 = Yao("大枣")
chufang = ChuFang("桂枝汤")
yao2.yaowei = yaowei2
yao2.yaoxing = yaoxing2
yao2.guijing = [jingluo2]
yao.yaowei = yaowei
yao.yaoxing = yaoxing
yao.guijing = [jingluo]
yao_chufang = Yao_ChuFang_Asso(yao, chufang, 7, "加热稀粥")
yao_chufang2 = Yao_ChuFang_Asso(yao2, chufang, 10, "掰开")
chufang_bingren = ChuFang_BingRen_Asso(bingren, chufang,
datetime.now())
yisheng.chufangs = [chufang]
Session.add_all([yaowei, yaoxing, jingluo, yao, chufang, yao_chufang])
Session.add_all([yaowei2, yaoxing2, jingluo2, yao2, yao_chufang2])
Session.add(dizhi)
Session.add(bingren)
Session.add(dizhi2)
Session.add(danwei)
Session.add(yisheng)
Session.add(chufang_bingren)
Session.commit()
items = Session.query(BingRen).filter(
BingRen.dianhua == "13673265899").first()
self.assertEqual(items.dizhi.jiedao, u"湘潭县云湖桥镇北岸村道林组83号")
items = Session.query(BingRen).join(DiZhi).filter(
DiZhi.sheng == "湖南").first()
self.assertEqual(items.dizhi.jiedao, u"湘潭县云湖桥镇北岸村道林组83号")
items = Session.query(ChuFang).join(YiSheng).filter(
YiSheng.xingming == "余浩").first()
import pdb
pdb.set_trace()
self.assertEqual(len(items.yaoes), 2)
self.assertEqual(items.yishengxm, "余浩")
items = Session.query(Yao).all()
items.extend(Session.query(YaoXing).all())
items.extend(Session.query(YaoWei).all())
items.extend(Session.query(JingLuo).all())
items.extend(Session.query(ChuFang).all())
items.extend(Session.query(BingRen).all())
items.extend(Session.query(YiSheng).all())
items.extend(Session.query(DanWei).all())
items.extend(Session.query(DiZhi).all())
for m in items:
Session.delete(m)
Session.commit()
