def setUp(self):
super().setUp()
self.score_info = (unique_long_id(), unique_long_id(),
unique_long_id(), unique_long_id(),
[unique_unicode_id(), unique_unicode_id()])
patcher = patch("cms.db.Dataset.score_type_object",
new_callable=PropertyMock)
self.score_type = patcher.start().return_value
self.addCleanup(patcher.stop)
self.call_args = list()
self.score_type.compute_score.side_effect = self.compute_score
self.contest = self.add_contest()
def new_jobs(number_of_jobs, prefix=None):
prefix = prefix if prefix is not None else ""
jobs = []
calls = []
for i in xrange(number_of_jobs):
job_params = [
ESOperation(ESOperation.EVALUATION,
unique_long_id(), unique_long_id(),
unique_unicode_id()).to_dict(),
"fake_task_type",
"fake_parameters_%s%d" % (prefix, i)
]
job = EvaluationJob(*job_params, info="%s%d" % (prefix, i))
jobs.append(job)
# Arguments to get_task_type are the same as for the job,
# but omitting the operation.
calls.append(call(*job_params[1:]))
return jobs, calls
def get_announcement(cls, contest=None, **kwargs):
"""Create an announcement"""
contest = contest if contest is not None else cls.get_contest()
args = {
"contest": contest,
"subject": unique_unicode_id(),
"text": unique_unicode_id(),
"timestamp": (contest.start + timedelta(0, unique_long_id())),
}
args.update(kwargs)
announcement = Announcement(**args)
return announcement
def get_token(cls, submission=None, **kwargs):
"""Create a token."""
submission = submission if submission is not None \
else cls.get_submission()
args = {
"submission": submission,
"timestamp": (submission.task.contest.start
+ timedelta(seconds=unique_long_id())),
}
args.update(kwargs)
token = Token(**args)
return token
def test_failure_due_to_max_number_on_task(self):
max_number = unique_long_id()
self.task.max_submission_number = max_number
# False only when we ask for task.
self.check_max_number.side_effect = \
lambda *args, **kwargs: "task" not in kwargs
with self.assertRaisesRegex(UnacceptableSubmission, "%d" % max_number):
self.call()
self.check_max_number.assert_called_with(
self.session, max_number, self.participation, task=self.task)
def test_failure_due_to_max_number_on_contest(self):
max_number = unique_long_id()
self.contest.max_user_test_number = max_number
# False only when we ask for contest.
self.check_max_number.side_effect = \
lambda *args, **kwargs: "contest" not in kwargs
with self.assertRaisesRegex(UnacceptableUserTest, "%d" % max_number):
self.call()
self.check_max_number.assert_called_with(
self.session, max_number, self.participation, contest=self.contest,
cls=UserTest)
def test_failure_due_to_max_number_on_task(self):
max_number = unique_long_id()
self.task.max_user_test_number = max_number
# False only when we ask for task.
self.check_max_number.side_effect = \
lambda *args, **kwargs: "task" not in kwargs
with six.assertRaisesRegex(self, UnacceptableUserTest,
"%d" % max_number):
self.call()
self.check_max_number.assert_called_with(
self.session, max_number, self.participation, task=self.task,
cls=UserTest)
def get_message(cls, participation=None, **kwargs):
"""Create a message."""
participation = participation if participation is not None \
else cls.get_participation()
args = {
"participation": participation,
"subject": unique_unicode_id(),
"text": unique_unicode_id(),
"timestamp": (participation.contest.start
+ timedelta(0, unique_long_id())),
}
args.update(kwargs)
message = Message(**args)
return message
def get_question(cls, participation=None, **kwargs):
"""Create a question."""
participation = participation if participation is not None \
else cls.get_participation()
args = {
"participation": participation,
"subject": unique_unicode_id(),
"text": unique_unicode_id(),
"question_timestamp": (participation.contest.start
+ timedelta(0, unique_long_id())),
}
args.update(kwargs)
question = Question(**args)
return question
def get_message(cls, participation=None, **kwargs):
"""Create a message."""
participation = participation if participation is not None \
else cls.get_participation()
args = {
"participation": participation,
"subject": unique_unicode_id(),
"text": unique_unicode_id(),
"timestamp": (participation.group.start
+ timedelta(0, unique_long_id())),
}
args.update(kwargs)
message = Message(**args)
return message
def add_token(self, submission=None, **kwargs):
"""Create a token and add it to the session"""
if submission is None:
submission = self.add_submission()
args = {
"submission":
submission,
"timestamp": (submission.task.contest.start +
timedelta(seconds=unique_long_id())),
}
args.update(kwargs)
token = Token(**args)
self.session.add(token)
return token
def test_failure_due_to_min_interval_on_task(self):
min_interval = timedelta(seconds=unique_long_id())
self.task.min_user_test_interval = min_interval
# False only when we ask for task.
self.check_min_interval.side_effect = \
lambda *args, **kwargs: "task" not in kwargs
with six.assertRaisesRegex(self, UnacceptableUserTest,
"%d" % min_interval.total_seconds()):
self.call()
self.check_min_interval.assert_called_with(
self.session, min_interval, self.timestamp, self.participation,
task=self.task, cls=UserTest)
def test_failure_due_to_min_interval_on_contest(self):
min_interval = timedelta(seconds=unique_long_id())
self.contest.min_submission_interval = min_interval
# False only when we ask for contest.
self.check_min_interval.side_effect = \
lambda *args, **kwargs: "contest" not in kwargs
with six.assertRaisesRegex(self, UnacceptableSubmission,
"%d" % min_interval.total_seconds()):
self.call()
self.check_min_interval.assert_called_with(
self.session, min_interval, self.timestamp, self.participation,
contest=self.contest)
def test_failure_due_to_min_interval_on_task(self):
min_interval = timedelta(seconds=unique_long_id())
self.task.min_user_test_interval = min_interval
# False only when we ask for task.
self.check_min_interval.side_effect = \
lambda *args, **kwargs: "task" not in kwargs
with self.assertRaisesRegex(UnacceptableUserTest,
"%d" % min_interval.total_seconds()):
self.call()
self.check_min_interval.assert_called_with(
self.session, min_interval, self.timestamp, self.participation,
task=self.task, cls=UserTest)
def test_failure_due_to_min_interval_on_contest(self):
min_interval = timedelta(seconds=unique_long_id())
self.contest.min_submission_interval = min_interval
# False only when we ask for contest.
self.check_min_interval.side_effect = \
lambda *args, **kwargs: "contest" not in kwargs
with self.assertRaisesRegex(UnacceptableSubmission,
"%d" % min_interval.total_seconds()):
self.call()
self.check_min_interval.assert_called_with(
self.session, min_interval, self.timestamp, self.participation,
contest=self.contest)
def get_submission(cls, task=None, participation=None, **kwargs):
"""Create a submission."""
task = task if task is not None \
else cls.get_task(contest=cls.get_contest())
participation = participation if participation is not None \
else cls.get_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)
return submission
def get_submission(cls, task=None, participation=None, **kwargs):
"""Create a submission."""
task = task if task is not None \
else cls.get_task(contest=cls.get_contest())
participation = participation if participation is not None \
else cls.get_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)
return submission
def get_announcement(cls, contest=None, **kwargs):
"""Create an announcement"""
contest = contest if contest is not None else cls.get_contest()
args = {
"contest":
contest,
"subject":
unique_unicode_id(),
"text":
unique_unicode_id(),
"timestamp":
(contest.main_group.start + timedelta(0, unique_long_id())),
}
args.update(kwargs)
announcement = Announcement(**args)
return announcement
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_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 get_question(cls, participation=None, **kwargs):
"""Create a question."""
participation = participation if participation is not None \
else cls.get_participation()
args = {
"participation":
participation,
"subject":
unique_unicode_id(),
"text":
unique_unicode_id(),
"question_timestamp":
(participation.group.start + timedelta(0, unique_long_id())),
}
args.update(kwargs)
question = Question(**args)
return question
def get_question(participation=None, **kwargs):
"""Create a question."""
participation = participation \
if participation is not None else DatabaseMixin.get_participation()
args = {
"participation":
participation,
"subject":
unique_unicode_id(),
"text":
unique_unicode_id(),
"question_timestamp":
(participation.contest.start + timedelta(0, unique_long_id())),
}
args.update(kwargs)
question = Question(**args)
return question
