class JudgeTest(TestCase):
def setUp(self):
self.contest = Contest()
self.contest.name = 'Test Contest'
self.contest.players_count = 1
self.contest.save()
self.judge = Judge()
self.judge.path = 'some path'
self.judge.was_default_judge = True
self.judge.contest = self.contest
self.judge.save()
self.match = Match()
self.match.judge = self.judge
self.match.contest = self.contest
self.match.save()
self.user = GladosUser.objects.create_user("test_user")
self.program = Program()
self.program.user = self.user
self.program.contest = self.contest
self.program.name = 'test program'
self.program.save()
self.match_log = MatchLog()
self.match_log.body = 'some random text'
self.match_log.match = self.match
self.match_log.save()
def create_programs(output=True):
"""Create programs and services from the DEFAULT_PROGRAMS dictionary, reflecting actual P-P organization"""
for program, services in DEFAULT_PROGRAMS.items():
p = Program()
p.name = program
if p.name in HAS_QUEUE:
p.has_queue = True
else:
p.has_queue = False
p.full_clean()
p.save()
if output:
print("Created program {}".format(p.name))
for service in services:
s = Service()
s.name = service
s.slug = f"{p.name}-{s.name}"
s.available = random_bool()
s.program = p
s.full_clean()
s.save()
if output:
print("Created {}: '{}'".format(p.name, s.slug))
""" Create forms for the program """
for _ in range(DEFAULT_NUMBER_FORMS):
create_form(p)
class ContestTest(TestCase):
def setUp(self):
self.contest = Contest()
self.contest.name = 'Test Contest'
self.contest.players_count = 1
self.contest.save()
self.judge = Judge()
self.judge.path = 'some path'
self.judge.was_default_judge = True
self.judge.contest = self.contest
self.judge.save()
self.match = Match()
self.match.judge = self.judge
self.match.contest = self.contest
self.match.save()
self.user = GladosUser.objects.create_user("test_user")
self.program = Program()
self.program.user = self.user
self.program.contest = self.contest
self.program.name = 'test program'
self.program.save()
self.match_log = MatchLog()
self.match_log.body = 'some random text'
self.match_log.match = self.match
self.match_log.save()
def test_contest_clean_start_end_time_invalid(self):
self.contest.end = timezone.now()
self.contest.start = self.contest.end + timezone.timedelta(days=1)
exception = None
try:
self.contest.save()
except ValidationError as e:
exception = e
self.assertTrue(exception, "contest start can't occur after contest end")
def test_contest_clean_start_end_time_correct(self):
self.contest.end = timezone.now()
self.contest.start = self.contest.end - timezone.timedelta(days=1)
exception = None
try:
self.contest.save()
except ValidationError as e:
exception = e
self.assertFalse(exception, "contest start can occur after contest end: {}".format(exception))
class ProgramMatchTest(TestCase):
def setUp(self):
self.contest = Contest()
self.contest.name = 'Test Contest'
self.contest.players_count = 1
self.contest.save()
self.judge = Judge()
self.judge.path = 'some path'
self.judge.was_default_judge = True
self.judge.contest = self.contest
self.judge.save()
self.match = Match()
self.match.judge = self.judge
self.match.contest = self.contest
self.match.save()
self.user = GladosUser.objects.create_user("test_user")
self.program = Program()
self.program.user = self.user
self.program.contest = self.contest
self.program.name = 'test program'
self.program.save()
self.match_log = MatchLog()
self.match_log.body = 'some random text'
self.match_log.match = self.match
self.match_log.save()
def test_program_match_uniqueness(self):
pm = ProgramMatch()
pm.program = self.program
pm.match = self.match
pm.save()
pm = ProgramMatch()
pm.program = self.program
pm.match = self.match
exception = None
try:
pm.save()
except IntegrityError as e:
exception = e
self.assertTrue(exception, "(program match) pair is not unique")
def handle(self, *args, **kwargs):
path = kwargs['path']
df = pd.read_csv(path)
upper_range = len(df)
print("Wait Data is being Loaded")
try:
prog = [
Program(
partner_id=(df['PARTNER CODE'][row]),
name=(df['PROGRAMME NAME'][row]),
code=df['Programme Code'][row],
total_budget=df['BUDGET (£)'][row],
) for row in range(0, upper_range)
]
prog_data = Program.objects.bulk_create(prog)
if prog_data:
self.stdout.write('Successfully loaded Partner data ..')
# for row in range(0, upper_range):
# print(df['Partner Name'][row])
except Exception as e:
print(e)
def cmd_start(self, what):
cmd = re.match('^\s*START\s*$', what, re.I)
if cmd:
if not self.user:
return "LOGIN REQUIRED\n", self
if not self.contest:
return "JOIN REQUIRED\n", self
if not self.program:
self.program = Program()
self.program.contest = self.contest
self.program.user = self.user
self.program.save()
return "OK\n", MatchParser(*self.args, contest=self.contest, user=self.user, program=self.program, **self.kwargs)
def import_program_report_dump(sourcefile):
with open(sourcefile) as f:
reader = csv.DictReader(f)
for row in reader:
site = Location.get_by_code(row['Site ID'])
if not site:
print(row)
continue
reporter = Connection.objects.get(identity=row['Mobile']).contact.worker
created = utc.localize(datetime.utcfromtimestamp(int(row['Timestamp'])))
modified = created
group = PatientGroup.get_by_code(row['Group'])
program = Program.get_by_code(row['Program'])
period_code = row['Period code']
period_number = row['Period number']
atot = int(row['Atot'])
tin = int(row['Tin'])
tout = int(row['Tout'])
dead = int(row['Dead'])
deft = int(row['DefT'])
dcur = int(row['Dcur'])
dmed = int(row['Dmed'])
ProgramReport.objects.create(site=site,
reporter=reporter,
created=created,
modified=modified,
group=group,
program=program,
period_number=period_number,
period_code=period_code,
new_marasmic_patients=atot,
patients_transferred_in=tin,
patients_transferred_out=tout,
patient_deaths=dead,
unconfirmed_patient_defaults=deft,
patients_cured=dcur,
unresponsive_patients=dmed)
print('Done')
def create_programs(output=True):
'''Create programs and services from the DEFAULT_PROGRAMS dictionary, reflecting actual P-P organization'''
for program, services in DEFAULT_PROGRAMS.items():
p = Program()
p.name = program
p.full_clean()
p.save()
if output:
print("Created program {}". format(p.name))
for service in services:
s = Service()
s.name = service
s.program = p
s.available = random_bool()
s.full_clean()
s.save()
if output:
print("Created {}: '{}'". format(p.name, s.name))
def import_lipschits(year):
#delete old
Program.objects.filter(date = '%s-01-01' % year).delete()
Section.objects.filter(program__date = '%s-01-01' % year).delete()
xml = parse(settings.PROJECT_DIR("LipschitsBooksinXML") + '/VP_%s.party-topicnr-content.xml' % year)
chapters = xml.getElementsByTagName("chapter")
for chapter in chapters:
pm_id = chapter.getAttributeNode('party').value
party, created = Party.objects.get_or_create(pm_id=pm_id, defaults={"full_name": pm_id, "name": pm_id})
program = Program(party=party, name = "Programma %s" % year, date = ('%s-01-01' % year))
print party, program
type = SectionType.objects.get(name="tekst")
program.save()
s = Section.objects.create(name = "Programma %s" % year, type=type, order=1, program=program)
program.section = s
program.save()
for p in chapter.getElementsByTagName("p"):
text = " ".join(t.nodeValue for t in p.childNodes if t.nodeType == t.TEXT_NODE)
text = process_text(text)
section = Section.objects.create(name = text.split(' ')[0], type=type, order=1, program=program, parent=s)
paragraph = section.paragraphs.create(text=text)
for theme in p.getElementsByTagName('theme'):
name = theme.getAttributeNode('id').value
name = name.replace('_',' ')
source, created = Source.objects.get_or_create(name = 'lipschits')
t, created = Topic.objects.get_or_create(
name = name,
source = source)
Selection.objects.create(
source = source,
paragraph = paragraph,
topic = t,)
class MatchLogTest(TestCase):
def setUp(self):
self.contest = Contest()
self.contest.name = 'Test Contest'
self.contest.players_count = 1
self.contest.save()
self.judge = Judge()
self.judge.path = 'some path'
self.judge.was_default_judge = True
self.judge.contest = self.contest
self.judge.save()
self.match = Match()
self.match.judge = self.judge
self.match.contest = self.contest
self.match.save()
self.user = GladosUser.objects.create_user("test_user")
self.program = Program()
self.program.user = self.user
self.program.contest = self.contest
self.program.name = 'test program'
self.program.save()
self.match_log = MatchLog()
self.match_log.body = 'some random text'
self.match_log.match = self.match
self.match_log.save()
def test_no_logs_before_match_start_invalid(self):
self.match.start = timezone.now()
self.match.save()
self.match_log.match = self.match
self.match_log.time = self.match.start - timezone.timedelta(days=1)
exception = None
try:
self.match_log.save()
except ValidationError as e:
exception = e
self.assertTrue(exception, "log with earlier date than match start")
def test_no_logs_before_match_start_correct(self):
self.match.start = timezone.now()
self.match.save()
self.match_log.match = self.match
self.match_log.time = self.match.start + timezone.timedelta(days=1)
exception = None
try:
self.match_log.save()
except ValidationError as e:
print e
exception = e
self.assertFalse(exception, "log with earlier date than match start: {}".format(exception))
class InitParser(ParserBase):
def __init__(self, *args, **kwargs):
super(InitParser, self).__init__(*args, **kwargs)
self.user = None
self.contest = None
self.program = None
def cmd_help(self, what):
cmd = re.match('^\s*help\s*$', what, re.I)
if cmd:
reply = 'OK\n'
reply += '# LOGIN <urlencoded username> PASSWORD <urlencoded password>\n'
reply += '# PROGRAM <urlencoded program name>\n'
reply += '# JOIN <contest_id>\n'
return reply, self
def cmd_empty(self, what):
cmd = re.match('^\s*$', what, re.I)
if cmd:
return "", self
def cmd_program(self, what):
cmd = re.match('^\s*PROGRAM\s+(?P<program>[^\s]+)\s*$',
what, re.I)
if cmd:
program_name = cmd.group('program')
if not self.user:
return "LOGIN REQUIRED\n", self
if not self.contest:
return "JOIN REQUIRED\n", self
program, created = Program.objects.get_or_create(contest=self.contest, user=self.user, name=program_name)
self.program = program
return "OK\n", self
def cmd_start(self, what):
cmd = re.match('^\s*START\s*$', what, re.I)
if cmd:
if not self.user:
return "LOGIN REQUIRED\n", self
if not self.contest:
return "JOIN REQUIRED\n", self
if not self.program:
self.program = Program()
self.program.contest = self.contest
self.program.user = self.user
self.program.save()
return "OK\n", MatchParser(*self.args, contest=self.contest, user=self.user, program=self.program, **self.kwargs)
def cmd_join(self, what):
cmd = re.match('^\s*JOIN\s+(?P<contest>\d+)\s*$',
what, re.I)
if cmd:
contest_id = cmd.group('contest')
if not self.user:
return "LOGIN REQUIRED\n", self
try:
self.contest = Contest.objects.get(pk=contest_id)
except Contest.DoesNotExist:
return "FAIL INVALID_CONTEST\n", self
if self.contest.default_judge is None:
return "FAIL INVALID_CONTEST\n", self
return "OK\n", self
def cmd_login(self, what):
cmd = re.match('^\s*LOGIN\s+(?P<user>[^\s]*)\s+PASSWORD\s+(?P<password>[^\s]*)\s*$',
what, re.I)
if cmd:
username = unquote(cmd.group('user'))
password = unquote(cmd.group('password'))
user = authenticate(username=username, password=password)
if not user:
return "FAIL INVALID_PASSWORD\n", self
self.user = user
return "OK\n", self
class MatchTest(TestCase):
def setUp(self):
self.contest = Contest()
self.contest.name = 'Test Contest'
self.contest.players_count = 1
self.contest.save()
self.judge = Judge()
self.judge.path = 'some path'
self.judge.was_default_judge = True
self.judge.contest = self.contest
self.judge.save()
self.match = Match()
self.match.judge = self.judge
self.match.contest = self.contest
self.match.save()
self.user = GladosUser.objects.create_user("test_user")
self.program = Program()
self.program.user = self.user
self.program.contest = self.contest
self.program.name = 'test program'
self.program.save()
self.match_log = MatchLog()
self.match_log.body = 'some random text'
self.match_log.match = self.match
self.match_log.save()
def test_matches_judge_was_default_invalid(self):
self.judge.was_default_judge = False
self.match.judge = self.judge
exception = None
try:
self.judge.save()
self.match.save()
except ValidationError as e:
exception = e
self.assertTrue(exception, "especially for Mr. Maciek")
def test_matches_judge_was_default_correct(self):
self.judge.was_default_judge = True
self.match.judge = self.judge
exception = None
try:
self.judge.save()
self.match.save()
except ValidationError as e:
exception = e
self.assertFalse(exception, "especially for Mr. Maciek: {}".format(exception))
def test_match_starts_after_contest_invalid(self):
self.contest.start = timezone.now()
self.match.start = self.contest.start - timezone.timedelta(days=1)
exception = None
try:
self.contest.save()
self.match.save()
except ValidationError as e:
exception = e
self.assertTrue(exception, "does not throw exception when match starts before the contest starts")
def test_match_starts_after_contest_correct(self):
self.contest.start = timezone.now()
self.match.start = self.contest.start + timezone.timedelta(days=1)
exception = None
try:
self.contest.save()
self.match.save()
except ValidationError as e:
exception = e
self.assertFalse(exception, "does throw exception even when match starts correctly after contest starts")
