def test_first_day_of_course(self):
"""Test that given a date returns you on the first day of the academic year"""
#
self.assertEqual(datetime(2020, 9, 1), first_day_of_course(datetime(2020, 10, 2)))
self.assertEqual(datetime(2020, 9, 1), first_day_of_course(datetime(2020, 9, 1)))
self.assertEqual(datetime(2019, 9, 1, 0, 0), first_day_of_course(datetime(2020, 3, 2)))
self.assertEqual(datetime(2020, 9, 1, 0, 0), first_day_of_course(datetime(2021, 7, 25)))
self.assertEqual(datetime(2021, 9, 1, 0, 0), first_day_of_course(datetime(2021, 9, 5)))
self.assertEqual(datetime(2020, 9, 1, 0, 0), first_day_of_course(datetime(2021, 8, 31)))
self.assertEqual(datetime(2023, 9, 1, 0, 0), first_day_of_course(datetime(2024, 2, 29)))
self.assertEqual(datetime(2002, 9, 1, 0, 0), first_day_of_course(datetime(2003, 1, 29)))
self.assertEqual(datetime(2035, 9, 1, 0, 0), first_day_of_course(datetime(2035, 10, 22)))
def test_download_ranking(self):
""" Test to download excel of results """
client = Client()
user = create_user('2222', 'tamara')
teacher = create_superuser('1111', 'teacher')
group_a = create_group('1A')
group_a.user_set.add(user)
start = first_day_of_course(datetime(2020, 9, 1))
end = datetime(2021, 3, 7).strftime('%Y-%m-%d')
collection = create_collection('Coleccion 1')
select_problem = create_select_problem(collection, 'SelectProblem ABC DEF')
sub = Submission.objects.create(code='SELECT * FROM test where n = 1000',
user=user, veredict_code=VeredictCode.WA, problem=select_problem)
sub.save()
Submission.objects.filter(id=sub.id).update(creation_date=datetime(2021, 3, 5))
client.login(username=teacher.username, password='******')
url = reverse('judge:download_ranking', args=[collection.pk])
response = client.get(url, {'group': group_a.id, 'start': start, 'end': end}, follow=True)
# Teacher download ranking
self.assertEqual(
response.get('Content-Disposition'),
"attachment; filename=ranking.xlsx",
)
self.assertEqual(
response.get('Content-Type'),
"application/xlsx"
)
file = tempfile.NamedTemporaryFile(mode='w+b', buffering=-1, suffix='.xlsx')
cont = response.content
file.write(cont)
work = openpyxl.load_workbook(file)
book = work.active
self.assertIn("Colección: " + collection.name_md, book.cell(row=1, column=1).value)
self.assertIn("1A", book.cell(row=3, column=1).value)
self.assertIn("1", book.cell(row=5, column=1).value)
self.assertIn(user.username, book.cell(row=5, column=2).value)
self.assertIn("0/1 (1)", book.cell(row=5, column=3).value)
self.assertIn("0", book.cell(row=5, column=4).value)
self.assertIn("0", book.cell(row=5, column=5).value)
file.close()
# Date or group invalid
response = client.get(url, {
'group': group_a.id, 'start': start, 'end': ''}, follow=True)
self.assertIn("Este campo es obligatorio", response.content.decode('utf-8'))
response = client.get(url, {
'group': group_a.id, 'start': 'eee', 'end': end}, follow=True)
self.assertIn("Introduzca una fecha válida", response.content.decode('utf-8'))
response = client.get(url, {
'group': group_a.id, 'end': end}, follow=True)
self.assertIn("Este campo es obligatorio",
response.content.decode('utf-8'))
response = client.get(url,
{'group': '1A', 'start': start, 'end': end}, follow=True)
self.assertIn('Introduzca un número entero', response.content.decode('utf-8'))
# User can't download ranking
client.logout()
client.login(username=user.username, password='******')
response = client.get(url, {'group': group_a.id, 'start': start, 'end': end}, follow=True)
self.assertIn('Forbidden', response.content.decode('utf-8'))
def test_show_result_classification(self):
"""test to show the classification"""
client = Client()
# Create 1 collection
collection = create_collection('Coleccion 1')
# Create 2 problems
select_problem = create_select_problem(collection,
'SelectProblem ABC DEF')
dml_problem = create_dml_problem(collection, 'insert a Number')
select_problem_2 = create_select_problem(collection,
'SelectProblem 2 DEF ABC')
# Create 3 users (2 students y 1 professor)
user_1 = create_user('12345', 'pepe')
user_2 = create_user('12345', 'ana')
teacher = create_superuser('12345', 'iker')
group_a = create_group('1A')
group_b = create_group('1B')
# add to group a all and to group b only the teacher
group_a.user_set.add(user_1)
group_a.user_set.add(user_2)
group_a.user_set.add(teacher)
group_b.user_set.add(teacher)
start = first_day_of_course(datetime(2020, 9, 1))
end = datetime.today().strftime('%Y-%m-%d')
# use the teacher to view the two groups
client.login(username=teacher.username, password='******')
classification_url = reverse('judge:result', args=[collection.pk])
submit_select_url = reverse('judge:submit', args=[select_problem.pk])
submit_select_2_url = reverse('judge:submit',
args=[select_problem_2.pk])
submit_dml_url = reverse('judge:submit', args=[dml_problem.pk])
# I see group b where there is only the teacher
# the table is empty because there is only the teacher
response = client.get(classification_url, {
'group': group_b.id,
'start': start,
'end': end
},
follow=True)
html = response.content.decode('utf-8')
self.assertEqual(response.status_code, 200)
self.assertNotIn(user_2.username, html)
self.assertNotIn(user_1.username, html)
# I find that there are two exercises in the collection
self.assertIn(select_problem.title_md, html)
self.assertIn(dml_problem.title_md, html)
self.assertIn(select_problem_2.title_md, html)
# I look at the group to where the students are
response = client.get(classification_url, {
'group': group_a.id,
'start': start,
'end': end
},
follow=True)
self.assertIn(user_1.username, response.content.decode('utf-8'))
self.assertIn(user_2.username, response.content.decode('utf-8'))
# I am connected to a non-existent group
response = client.get(classification_url, {
'group': 999,
'start': start,
'end': end
},
follow=True)
self.assertEqual(response.status_code, 404)
# I connect to a non-numeric group
response = client.get(classification_url, {
'group': '1A',
'start': start,
'end': end
},
follow=True)
msg = 'Enter a whole number'
self.assertEqual(response.status_code, 404)
self.assertIn(msg, response.content.decode('utf-8'))
client.logout()
client.login(username=user_1.username, password='******')
# I connect to pepe at 1b
response = client.get(classification_url, {'group': group_b.id},
follow=True)
self.assertEqual(response.status_code, 403)
client.post(submit_select_url,
{'code': 'SELECT * FROM test where n = 1000'},
follow=True)
client.post(submit_select_url, {'code': select_problem.solution},
follow=True)
client.post(submit_dml_url,
{'code': 'SELECT * FROM test where n = 1000'},
follow=True)
client.post(submit_dml_url,
{'code': 'SELECT * FROM test where n = 1000'},
follow=True)
client.post(submit_dml_url,
{'code': 'SELECT * FROM test where n = 1000'},
follow=True)
client.post(submit_dml_url, {'code': dml_problem.solution},
follow=True)
response = client.get(classification_url, {'group': group_a.id},
follow=True)
self.assertIn('1/2 (2)', response.content.decode('utf-8'))
self.assertIn('1/4 (4)', response.content.decode('utf-8'))
self.assertIn('6', response.content.decode('utf-8'))
client.logout()
client.login(username=user_2.username, password='******')
client.post(submit_select_url, {'code': select_problem.solution},
follow=True)
client.post(submit_select_url, {'code': select_problem.solution},
follow=True)
client.post(submit_select_url, {'code': select_problem.solution},
follow=True)
client.post(submit_dml_url, {'code': 'Select * from test'},
follow=True)
client.post(submit_dml_url, {'code': 'Select * from test'},
follow=True)
client.post(submit_dml_url, {'code': dml_problem.solution},
follow=True)
response = client.get(classification_url, {'group': group_a.id},
follow=True)
html = response.content.decode('utf-8')
for fragment in ['3/3 (1)', '1/3 (3)', '4']:
self.assertIn(fragment, html)
# ana's position is better than pepe's position
self.assertLess(html.index('ana'), html.index('pepe'))
client.post(submit_select_2_url,
{'code': 'SELECT * FROM test where n = 1000'},
follow=True)
response = client.get(classification_url, {'group': group_a.id},
follow=True)
self.assertIn('0/1 (1)', response.content.decode('utf-8'))
client.logout()
def test_show_result_classification_date(self):
"""test to show the classification with dates"""
client = Client()
submissions_url = reverse('judge:submissions')
# Create 1 collection
collection = create_collection('Coleccion 1')
classification_url = reverse('judge:result', args=[collection.pk])
# Create 1 problem
select_problem = create_select_problem(collection,
'SelectProblem ABC DEF')
# Create 3 users (2 students y 1 professor)
user_1 = create_user('12345', 'pepe')
user_2 = create_user('12345', 'ana')
teacher = create_superuser('12345', 'iker')
# Create 1 group
group_a = create_group('1A')
# add the students and the teacher to the group a
group_a.user_set.add(user_1)
group_a.user_set.add(user_2)
group_a.user_set.add(teacher)
# create course start date and today's date
start = first_day_of_course(datetime(2020, 9, 1))
end = datetime(2021, 3, 7).strftime('%Y-%m-%d')
# I connect to a student and in the url I insert dates
client.login(username=user_1.username, password='******')
response = client.get(classification_url, follow=True)
self.assertEqual(200, response.status_code)
response = client.get(classification_url, {
'group': group_a.id,
'start': start,
'end': end
},
follow=True)
html = response.content.decode('utf-8')
self.assertIn('Forbidden', html)
# the first student makes three submissions (1/3 (3))
sub1 = Submission.objects.create(
code='SELECT * FROM test where n = 1000',
user=user_1,
veredict_code=VeredictCode.WA,
problem=select_problem)
sub1.save()
Submission.objects.filter(id=sub1.id).update(
creation_date=datetime(2021, 3, 5))
sub2 = Submission.objects.create(
code='SELECT * FROM test where n = 1000',
user=user_1,
veredict_code=VeredictCode.WA,
problem=select_problem)
sub2.save()
Submission.objects.filter(id=sub2.id).update(
creation_date=datetime(2021, 3, 5))
sub3 = Submission.objects.create(code=select_problem.solution,
user=user_1,
veredict_code=VeredictCode.AC,
problem=select_problem)
sub3.save()
Submission.objects.filter(id=sub3.id).update(
creation_date=datetime(2021, 3, 7))
client.logout()
client.login(username=user_2.username, password='******')
# the second student makes two submissions (1/2 (1))
sub4 = Submission.objects.create(code=select_problem.solution,
user=user_2,
veredict_code=VeredictCode.AC,
problem=select_problem)
sub4.save()
Submission.objects.filter(id=sub4.id).update(
creation_date=datetime(2021, 3, 7))
sub5 = Submission.objects.create(
code='SELECT * FROM test where n = 1000',
user=user_2,
veredict_code=VeredictCode.WA,
problem=select_problem)
sub5.save()
Submission.objects.filter(id=sub5.id).update(
creation_date=datetime(2021, 3, 7))
response = client.get(
submissions_url, {
'problem_id': select_problem.pk,
'user_id': user_2.id,
'start': first_day_of_course(datetime(2020, 9, 1)),
'end': datetime(2021, 3, 7).strftime('%Y-%m-%d')
},
follow=True)
self.assertIn('Forbidden', response.content.decode('utf-8'))
client.logout()
client.login(username=teacher.username, password='******')
response = client.get(classification_url, {
'group': group_a.id,
'start': start,
'end': end
},
follow=True)
self.assertIn(user_2.username, response.content.decode('utf-8'))
self.assertEqual(response.status_code, 200)
self.assertIn(user_2.username, response.content.decode('utf-8'))
self.assertIn(user_1.username, response.content.decode('utf-8'))
for fragment in ['1/3 (3)', '3', '1', '1/2 (1)']:
self.assertIn(fragment, response.content.decode('utf-8'))
last_end_date = datetime(2021, 3, 5).strftime('%Y-%m-%d')
# For yesterday's date student one must have two failed submissions and no correct submissions 0/2 (2)
response = client.get(classification_url, {
'group': group_a.id,
'start': start,
'end': last_end_date
},
follow=True)
for fragment in ['0/2 (2)', '0', '0', '0/0 (0)']:
self.assertIn(fragment, response.content.decode('utf-8'))
# I test date formatting and incorrect or misplaced dates
good_start_date = datetime(2019, 9, 1).strftime('%Y-%m-%d')
wrong_end_date = datetime(2222, 2, 2).strftime('%Y-%m-%d')
response = client.get(classification_url, {
'group': group_a.id,
'start': end,
'end': start
},
follow=True)
self.assertIn(
'¡Error! La fecha inicial no puede ser mayor que la fecha final.',
response.content.decode('utf-8'))
response = client.get(classification_url, {
'group': group_a.id,
'start': good_start_date,
'end': end
},
follow=True)
self.assertEqual(response.status_code, 200)
response = client.get(classification_url, {
'group': group_a.id,
'start': start,
'end': wrong_end_date
},
follow=True)
self.assertIn(
"¡Error! La fecha final no puede ser mayor que la fecha de hoy.",
response.content.decode('utf-8'))
response = client.get(classification_url, {
'group': group_a.id,
'start': start,
'end': ''
},
follow=True)
self.assertIn("field is required", response.content.decode('utf-8'))
response = client.get(classification_url, {
'group': group_a.id,
'start': 'eee',
'end': end
},
follow=True)
self.assertIn("Enter a valid date", response.content.decode('utf-8'))
response = client.get(classification_url, {
'group': group_a.id,
'end': end
},
follow=True)
self.assertIn("field is required", response.content.decode('utf-8'))
response = client.get(classification_url, {
'group': group_a.id,
'start': start,
'end': start
},
follow=True)
for fragment in ['0/0 (0)', '0', '0']:
self.assertIn(fragment, response.content.decode('utf-8'))
def test_logged(self):
"""Connections from a logged user"""
client = Client()
collection = create_collection('Colleccion de prueba XYZ')
problem = create_select_problem(collection, 'SelectProblem ABC DEF')
problem_dml = create_dml_problem(collection, 'DMLProblem')
user = create_user('5555', 'pepe')
create_user('1234', 'ana')
submission = create_submission(
problem, user, VeredictCode.AC,
'select *** from *** where *** and more')
client.login(username='******', password='******')
collections_url = reverse('judge:collections')
collection_url = reverse('judge:collection', args=[collection.pk])
problem_url = reverse('judge:problem', args=[problem.pk])
no_problem_url = reverse('judge:problem', args=[8888888])
submit_url = reverse('judge:submit', args=[problem.pk])
submit_dml_url = reverse('judge:submit', args=[problem_dml.pk])
submissions_url = reverse('judge:submissions')
submission_url = reverse('judge:submission', args=[submission.pk])
pass_done_url = reverse('judge:password_change_done')
# Root redirects to collection
response = client.get('/sql/', follow=True)
self.assertEqual(response.redirect_chain, [(collections_url, 302)])
# OK and one collection with title
response = client.get(collections_url, follow=True)
self.assertEqual(response.status_code, 200)
self.assertIn(collection.name_md, response.content.decode('utf-8'))
# OK and one problem in collection
response = client.get(collection_url, follow=True)
self.assertEqual(response.status_code, 200)
self.assertIn(problem.title_md, response.content.decode('utf-8'))
# OK and title in problem page
response = client.get(problem_url, follow=True)
self.assertEqual(response.status_code, 200)
self.assertIn(problem.title_md, response.content.decode('utf-8'))
# NotFound
response = client.get(no_problem_url, follow=True)
self.assertEqual(response.status_code, 404)
# JSON with AC
response = client.post(submit_url, {'code': problem.solution},
follow=True)
self.assertEqual(response.json()['veredict'], VeredictCode.AC)
# JSON with WA
response = client.post(submit_url,
{'code': 'SELECT * FROM test where n = 1000'},
follow=True)
self.assertEqual(response.json()['veredict'], VeredictCode.WA)
# JSON with VE
response = client.post(submit_url, {'code': ''}, follow=True)
self.assertEqual(response.json()['veredict'], VeredictCode.VE)
# JSON with VE
response = client.post(
submit_url, {'code': 'select * from test; select * from test;'},
follow=True)
self.assertEqual(response.json()['veredict'], VeredictCode.VE)
# JSON with TLE
tle = judge.tests.test_oracle.SELECT_TLE
response = client.post(submit_url, {'code': tle}, follow=True)
self.assertEqual(response.json()['veredict'], VeredictCode.TLE)
# JSON with RE (table and column do not exist)
response = client.post(submit_url, {'code': 'SELECT pumba FROM timon'},
follow=True)
self.assertEqual(response.json()['veredict'], VeredictCode.RE)
# There must be 7 submission to problem
response = client.get(submissions_url, follow=True)
self.assertEqual(
response.content.decode('utf-8').count(problem.title_md), 7)
# JSON with VE (new Problem)
response = client.post(submit_dml_url,
{'code': 'SELECT * FROM test where n = 1000'},
follow=True)
self.assertEqual(response.json()['veredict'], VeredictCode.VE)
# There must be 1 submission to new problem
response = client.get(submissions_url, {
'problem_id': problem_dml.pk,
'user_id': user.id
},
follow=True)
self.assertEqual(
response.content.decode('utf-8').count(problem_dml.title_md), 1)
# problem_id is not numeric
response = client.get(submissions_url, {
'problem_id': 'problem',
'user_id': 'user'
},
follow=True)
self.assertEqual(response.status_code, 404)
self.assertIn('El identificador no tiene el formato correcto',
response.content.decode('utf-8'))
# Submission contains user code
response = client.get(submission_url, follow=True)
self.assertIn('select *** from *** where *** and more',
response.content.decode('utf-8'))
# status_code OK
response = client.get(pass_done_url, follow=True)
self.assertEqual(response.status_code, 200)
# Only submission from the same user
client.logout()
client.login(username='******', password='******')
# Submssion contains user code
response = client.get(submission_url, follow=True)
self.assertEqual(response.status_code, 403)
response = client.get(submissions_url, {
'problem_id': problem_dml.pk,
'user_id': user.id
},
follow=True)
self.assertIn('Forbidden', response.content.decode('utf-8'))
client.logout()
# create a teacher and show submission to user pepe
teacher = create_superuser('1111', 'teacher')
client.login(username=teacher.username, password='******')
response = client.get(
submissions_url, {
'problem_id': problem_dml.pk,
'user_id': user.id,
'start': first_day_of_course(datetime(2020, 9, 1)),
'end': datetime.today().strftime('%Y-%m-%d')
},
follow=True)
self.assertEqual(
response.content.decode('utf-8').count(problem_dml.title_md), 1)
client.logout()
def test_download_ranking(self):
""" Test to download excel of results """
client = Client()
user = create_user('2222', 'tamara')
teacher = create_superuser('1111', 'teacher')
group_a = create_group('1A')
group_a.user_set.add(user)
start = first_day_of_course(datetime(2020, 9, 1)).strftime('%Y-%m-%d')
end = datetime(2021, 3, 7).strftime('%Y-%m-%d')
collection = create_collection('Coleccion 1')
select_problem = create_select_problem(collection, 'SelectProblem1')
select_problem_2 = create_select_problem(collection, 'SelectProblem2')
sub1 = Submission.objects.create(
code='SELECT * FROM test where n = 1000',
user=user,
verdict_code=VerdictCode.WA,
problem=select_problem)
Submission.objects.filter(id=sub1.id).update(
creation_date=datetime(2021, 3, 1))
sub2 = Submission.objects.create(
code='SELECT * FROM test where n = 1000',
user=user,
verdict_code=VerdictCode.AC,
problem=select_problem_2)
Submission.objects.filter(id=sub2.id).update(
creation_date=datetime(2021, 3, 2))
sub3 = Submission.objects.create(
code='SELECT * FROM test where n = 1000',
user=user,
verdict_code=VerdictCode.RE,
problem=select_problem_2)
Submission.objects.filter(id=sub3.id).update(
creation_date=datetime(2021, 3, 4))
client.login(username=teacher.username, password='******')
url = reverse('judge:download_ranking', args=[collection.pk])
response = client.get(url, {
'group': group_a.id,
'start': start,
'end': end
},
follow=True)
# Teacher download ranking
self.assertEqual(
response.get('Content-Disposition'),
'attachment; filename="ranking.ods"',
)
self.assertEqual(response.get('Content-Type'),
"application/vnd.oasis.opendocument.spreadsheet")
cont = response.getvalue()
buffer = io.BytesIO(cont)
buffer.seek(0)
data = get_data(buffer)
self.assertIn(collection.name_md, data['1A'][0][1])
self.assertEqual("1A", data['1A'][1][1])
self.assertEqual(1, data['1A'][6][0])
self.assertEqual(user.username, data['1A'][6][1])
self.assertEqual("0/1", data['1A'][6][2]) # SelectProblem1
self.assertEqual("1/2 (1)", data['1A'][6][3]) # SelectProblem2
self.assertEqual(1, data['1A'][6][4]) # Score
self.assertEqual(1, data['1A'][6][5]) # Solved
# Date or group invalid
response = client.get(url, {
'group': group_a.id,
'start': end,
'end': start
},
follow=True)
self.assertIn("La fecha inicial no puede ser mayor que la fecha final",
response.content.decode('utf-8'))
response = client.get(url, {
'group': group_a.id,
'start': start,
'end': datetime(4000, 7, 7).strftime('%Y-%m-%d')
},
follow=True)
self.assertIn("La fecha final no puede ser mayor que la fecha de hoy",
response.content.decode('utf-8'))
response = client.get(url, {
'group': group_a.id,
'start': start,
'end': ''
},
follow=True)
self.assertIn("Este campo es obligatorio",
response.content.decode('utf-8'))
response = client.get(url, {
'group': group_a.id,
'start': 'eee',
'end': end
},
follow=True)
self.assertIn("Introduzca una fecha válida",
response.content.decode('utf-8'))
response = client.get(url, {
'group': group_a.id,
'end': end
},
follow=True)
self.assertIn("Este campo es obligatorio",
response.content.decode('utf-8'))
response = client.get(url, {
'group': '1A',
'start': start,
'end': end
},
follow=True)
self.assertIn('Introduzca un número entero',
response.content.decode('utf-8'))
# Students cannot download ranking
client.logout()
client.login(username=user.username, password='******')
response = client.get(url, {
'group': group_a.id,
'start': start,
'end': end
},
follow=True)
self.assertIn('pero no está autorizado a acceder a esta página',
response.content.decode('utf-8'))
def test_show_result_classification(self):
""" Ranking is correct """
client = Client()
# Create 1 collection
collection = create_collection('Coleccion 1')
# Create 2 problems
select_problem = create_select_problem(collection, 'SelectProblem ABC DEF')
dml_problem = create_dml_problem(collection, 'insert a Number')
select_problem_2 = create_select_problem(collection, 'SelectProblem 2 DEF ABC')
# Create 3 users (2 students y 1 professor)
user_1 = create_user('12345', 'pepe')
user_2 = create_user('12345', 'ana')
teacher = create_superuser('12345', 'iker')
group_a = create_group('1A')
group_b = create_group('1B')
# add to group a all and to group b only the teacher
group_a.user_set.add(user_1)
group_a.user_set.add(user_2)
group_a.user_set.add(teacher)
group_b.user_set.add(teacher)
start = first_day_of_course(datetime(2020, 9, 1)).strftime('%Y-%m-%d')
end = datetime.today().strftime('%Y-%m-%d')
# use the teacher to view the two groups
client.login(username=teacher.username, password='******')
classification_url = reverse('judge:result', args=[collection.pk])
# I see group b where there is only the teacher
# the table is empty because there is only the teacher
response = client.get(classification_url, {
'group': group_b.id, 'start': start, 'end': end}, follow=True)
html = response.content.decode('utf-8')
self.assertEqual(response.status_code, 200)
self.assertNotIn(user_2.username, html)
self.assertNotIn(user_1.username, html)
# I find that there are two exercises in the collection
self.assertIn(select_problem.title_html, html)
self.assertIn(dml_problem.title_html, html)
self.assertIn(select_problem_2.title_html, html)
# I look at the group to where the students are
response = client.get(classification_url,
{'group': group_a.id, 'start': start, 'end': end}, follow=True)
self.assertIn(user_1.username, response.content.decode('utf-8'))
self.assertIn(user_2.username, response.content.decode('utf-8'))
# I am connected to a non-existent group
response = client.get(classification_url,
{'group': 999, 'start': start, 'end': end}, follow=True)
self.assertEqual(response.status_code, 404)
# I connect to a non-numeric group
response = client.get(classification_url,
{'group': '1A', 'start': start, 'end': end}, follow=True)
msg = 'Introduzca un número entero'
self.assertEqual(response.status_code, 404)
self.assertIn(msg, response.content.decode('utf-8'))
client.logout()
# I connect to pepe at 1b
client.login(username=user_1.username, password='******')
response = client.get(classification_url, {'group': 'patato'}, follow=True)
self.assertEqual(response.status_code, 404)
self.assertIn('Introduzca un número entero', response.content.decode('utf_8'))
response = client.get(classification_url, {'group': group_b.id}, follow=True)
self.assertEqual(response.status_code, 403)
Submission.objects.create(problem=select_problem, code=' ', verdict_code=VerdictCode.WA, user=user_1)
Submission.objects.create(problem=select_problem, code=' ', verdict_code=VerdictCode.WA, user=user_1)
Submission.objects.create(problem=select_problem, code=' ', verdict_code=VerdictCode.AC, user=user_1)
Submission.objects.create(problem=dml_problem, code=' ', verdict_code=VerdictCode.WA, user=user_1)
Submission.objects.create(problem=dml_problem, code=' ', verdict_code=VerdictCode.WA, user=user_1)
Submission.objects.create(problem=dml_problem, code=' ', verdict_code=VerdictCode.WA, user=user_1)
Submission.objects.create(problem=dml_problem, code=' ', verdict_code=VerdictCode.AC, user=user_1)
response = client.get(classification_url, {'group': group_a.id}, follow=True)
for expected in ['1/3 (3)', '1/4 (4)', '7', '2']:
self.assertIn(expected, response.content.decode('utf-8'))
client.logout()
client.login(username=user_2.username, password='******')
Submission.objects.create(problem=select_problem, code=' ', verdict_code=VerdictCode.AC, user=user_2)
Submission.objects.create(problem=select_problem, code=' ', verdict_code=VerdictCode.AC, user=user_2)
Submission.objects.create(problem=select_problem, code=' ', verdict_code=VerdictCode.AC, user=user_2)
Submission.objects.create(problem=dml_problem, code=' ', verdict_code=VerdictCode.WA, user=user_2)
Submission.objects.create(problem=dml_problem, code=' ', verdict_code=VerdictCode.WA, user=user_2)
Submission.objects.create(problem=dml_problem, code=' ', verdict_code=VerdictCode.AC, user=user_2)
response = client.get(classification_url, {'group': group_a.id}, follow=True)
html = response.content.decode('utf-8')
for fragment in ['3/3 (1)', '1/3 (3)', '4']:
self.assertIn(fragment, html)
# ana's position is better than pepe's position
self.assertLess(html.index('ana'), html.index('pepe'))
Submission.objects.create(problem=select_problem_2, code=' ', verdict_code=VerdictCode.WA, user=user_2)
response = client.get(classification_url, {'group': group_a.id}, follow=True)
self.assertIn('0/1', response.content.decode('utf-8'))
client.logout()
def test_permission_ranking(self):
""" Test to access the ranking from different groups """
# Create 1 collection with 1 problem
collection = create_collection('Coleccion 1')
classification_url = reverse('judge:result', args=[collection.pk])
# Create 3 users (2 students y 1 staff)
user_1 = create_user('12345', 'pepe')
user_2 = create_user('12345', 'ana')
teacher = create_superuser('12345', 'iker')
# Create 2 groups
group_b = create_group('1B')
group_a = create_group('1A')
# add the students and the teacher to the group a, and only user 2 to group B
group_a.user_set.add(user_1)
group_a.user_set.add(user_2)
group_a.user_set.add(teacher)
group_b.user_set.add(user_2)
# create course start date and today's date
start = first_day_of_course(datetime(2020, 9, 1)).strftime('%Y-%m-%d')
end = datetime(2021, 3, 7).strftime('%Y-%m-%d')
# Checks access to rankings: 'pepe' only to group A, 'ana' to group A and B,
# 'iker' also to both groups as staff
client = Client()
client.login(username='******', password='******')
response = client.get(classification_url, {'group': group_a.id}, follow=True)
self.assertEqual(response.status_code, 200)
response = client.get(classification_url, {'group': group_b.id}, follow=True)
self.assertEqual(response.status_code, 403)
self.assertIn('Forbidden', response.content.decode('utf-8'))
response = client.get(classification_url, follow=True)
self.assertEqual(response.status_code, 200)
self.assertIn('1A', response.content.decode('utf-8'))
client.logout()
client.login(username='******', password='******')
response = client.get(classification_url, {'group': group_a.id}, follow=True)
self.assertEqual(response.status_code, 200)
response = client.get(classification_url, {'group': group_b.id}, follow=True)
self.assertEqual(response.status_code, 200)
response = client.get(classification_url, follow=True)
self.assertEqual(response.status_code, 200)
self.assertIn('1B', response.content.decode('utf-8'))
client.logout()
client.login(username='******', password='******')
response = client.get(classification_url, {'group': group_a.id, 'start': start, 'end': end}, follow=True)
self.assertEqual(response.status_code, 200)
response = client.get(classification_url, {'group': group_b.id, 'start': start, 'end': end}, follow=True)
self.assertEqual(response.status_code, 200)
response = client.get(classification_url, {'group': group_a.id, 'end': end}, follow=True)
self.assertEqual(response.status_code, 200)
response = client.get(classification_url, {'group': group_b.id, 'start': start}, follow=True)
self.assertEqual(response.status_code, 200)
response = client.get(classification_url, {'group': group_b.id}, follow=True)
self.assertEqual(response.status_code, 200)
response = client.get(classification_url, follow=True)
self.assertEqual(response.status_code, 200)
self.assertIn('1B', response.content.decode('utf-8'))
client.logout()