def test_get_podium_achievement(self):
"""Test if get correctly a podium achievement"""
client = Client()
podium_achievement = PodiumAchievementDefinition(
name={"es": "Top 1"},
description={"es": 'Se el primero'},
num_problems=1,
position=1)
podium_achievement.save()
coll = create_collection('Test Podium')
problem = create_select_problem(coll, 'Select 1')
user = create_user('passwordmichu', 'michu')
client.login(username='******', password='******')
submit_select_url = reverse('judge:submit', args=[problem.pk])
client.post(submit_select_url, {'code': problem.solution}, follow=True)
achievements_url = reverse('judge:achievements', args=[user.pk])
response = client.get(achievements_url, follow=True)
self.assertIn('Fecha', response.content.decode('utf-8'))
def test_get_collection_achievement(self):
"""Test if get correctly a collection achievement"""
client = Client()
coll = create_collection('Test Solved')
coll_achievement = NumSolvedCollectionAchievementDefinition(
name={"es": 'Solo 1'},
description={"es": 'Acierta 1'},
num_problems=1,
collection=coll)
coll_achievement.save()
problem = create_select_problem(coll, 'Select 1')
user = create_user('passwordmichu', 'michu')
client.login(username='******', password='******')
submit_select_url = reverse('judge:submit', args=[problem.pk])
client.post(submit_select_url, {'code': problem.solution}, follow=True)
achievements_url = reverse('judge:achievements', args=[user.pk])
response = client.get(achievements_url, follow=True)
self.assertIn('Fecha', response.content.decode('utf-8'))
def test_incorrect_submit_get_achievement(self):
"""Test if an incorrect submission get an achievement"""
client = Client()
user = create_user('passwordmazepin', 'mazepin')
coll = create_collection('Coleccion de cartas')
problem = create_select_problem(coll, 'Problema')
ach_submissions = NumSubmissionsProblemsAchievementDefinition(
name={"es": 'Un envio'},
description={"es": 'Envia una solucion para un problema'},
num_problems=1,
num_submissions=1)
ach_submissions.save()
client.login(username='******', password='******')
submit_select_url = reverse('judge:submit', args=[problem.pk])
client.post(submit_select_url, {'code': 'MAL'},
follow=True) # Validation Error, too short
self.assertEqual(
ObtainedAchievement.objects.filter(user=user).count(), 1)
def test_rejudge(self):
""" Test that rejudge correctly detects submission whose verdict changes """
collection = create_collection("test collection")
problem = create_select_problem(collection, "example")
user = create_user(passwd='1111', username='******')
subs = [
Submission(code=problem.solution,
veredict_code=VeredictCode.IE,
user=user,
problem=problem), # IE->AC
Submission(code='SELECT * FROM dual',
veredict_code=VeredictCode.IE,
user=user,
problem=problem), # IE->WA
Submission(code='SELECT * FRO dual',
veredict_code=VeredictCode.IE,
user=user,
problem=problem), # IE->RE
]
for sub in subs:
sub.save()
sub.creation_date = datetime.datetime(2020, 9,
15) # Sets an older date
sub.save()
file_desc, filename = mkstemp('_rejudge')
os.close(
file_desc) # To avoid problems when removing the file in Windows
rejudge(VeredictCode.IE, filename, tests=True)
with open(filename, 'r') as summary_file:
summary = summary_file.read()
self.assertIn('IE --> AC', summary)
self.assertIn('IE --> WA', summary)
self.assertIn('IE --> RE', summary)
self.assertNotIn('IE --> IE', summary)
os.remove(filename)
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_return_none(self):
"""Test if an user don't solve a problem, function solved_position return None"""
user = create_user('passwordmichu', 'michu')
coll = create_collection('Coleccion de cartas')
problem = create_select_problem(coll, 'Problema')
self.assertIsNone(problem.solved_position(user))
def test_obtained_achievements_date(self):
"""Test if the dates of the obtained achievements are correct"""
user = create_user('passwordmichu', 'michu')
coll = create_collection('Coleccion de cartas')
problem_1 = create_select_problem(coll, 'Problema 1')
problem_2 = create_select_problem(coll, 'Problema 2')
sub_1 = Submission(code='nada', veredict_code=VeredictCode.AC, user=user, problem=problem_1)
sub_2 = Submission(code='nada', veredict_code=VeredictCode.AC, user=user, problem=problem_2)
sub_1.save()
sub_2.save()
Submission.objects.filter(id=sub_1.id).update(creation_date=datetime(2006, 3, 5))
# sub_1_u = submission 1 updated
sub_1_u = Submission.objects.get(id=sub_1.id)
Submission.objects.filter(id=sub_2.id).update(creation_date=datetime(2020, 3, 5))
sub_2_u = Submission.objects.get(id=sub_2.id)
# Test NumSolvedAchievementDefinition
ach_solved = NumSolvedAchievementDefinition(name='Resolvista', description='Resuelve 2 problemas',
num_problems=2)
ach_solved.save()
date = ObtainedAchievement.objects.filter(user=user).values_list('obtained_date', flat=True)
self.assertEqual(date[0], sub_2_u.creation_date)
ach_solved.num_problems = 1
ach_solved.save()
date = ObtainedAchievement.objects.filter(user=user).values_list('obtained_date', flat=True)
self.assertEqual(date[0], sub_1_u.creation_date)
ObtainedAchievement.objects.all().delete()
# Test NumSolvedCollectionAchievementDefinition
ach_coll = NumSolvedCollectionAchievementDefinition(name='Coleccionista', description='Resuelve 2 \
problemas de esta coleccion', num_problems=2,
collection=coll)
ach_coll.save()
date = ObtainedAchievement.objects.filter(user=user).values_list('obtained_date', flat=True)
self.assertEqual(date[0], sub_2_u.creation_date)
ach_coll.num_problems = 1
ach_coll.save()
date = ObtainedAchievement.objects.filter(user=user).values_list('obtained_date', flat=True)
self.assertEqual(date[0], sub_1_u.creation_date)
ObtainedAchievement.objects.all().delete()
# Test PodiumAchievementDefinition
ach_podium = PodiumAchievementDefinition(name='Presidente del podio', description='Consigue ser el primero',
num_problems=2, position=1)
ach_podium.save()
date = ObtainedAchievement.objects.filter(user=user).values_list('obtained_date', flat=True)
self.assertEqual(date[0], sub_2_u.creation_date)
ach_podium.num_problems = 1
ach_podium.save()
date = ObtainedAchievement.objects.filter(user=user).values_list('obtained_date', flat=True)
self.assertEqual(date[0], sub_1_u.creation_date)
ObtainedAchievement.objects.all().delete()
# Test NumSolvedTypeAchievementDefinition
ach_type = NumSolvedTypeAchievementDefinition(name='Tipos', description='Resuelve un problema SELECT',
num_problems=2, problem_type=ProblemType.SELECT.name)
ach_type.save()
date = ObtainedAchievement.objects.filter(user=user).values_list('obtained_date', flat=True)
self.assertEqual(date[0], sub_2_u.creation_date)
ach_type.num_problems = 1
ach_type.save()
date = ObtainedAchievement.objects.filter(user=user).values_list('obtained_date', flat=True)
self.assertEqual(date[0], sub_1_u.creation_date)
ObtainedAchievement.objects.all().delete()
# Test NumSubmissionsProblemsAchievementDefinition
ach_submissions = NumSubmissionsProblemsAchievementDefinition(name='Ya van dos problemas',
description='Realiza un envio en dos problemas',
num_problems=2, num_submissions=2)
ach_submissions.save()
date = ObtainedAchievement.objects.filter(user=user).values_list('obtained_date', flat=True)
self.assertEqual(date[0], sub_2_u.creation_date)
ach_submissions.num_problems = 1
ach_submissions.num_submissions = 1
ach_submissions.save()
date = ObtainedAchievement.objects.filter(user=user).values_list('obtained_date', flat=True)
self.assertEqual(date[0], sub_1_u.creation_date)
ObtainedAchievement.objects.all().delete()
def test_signal_update_achievement(self):
"""Test for check signals"""
# Create two users for test all the achievements. Two for the podium
client = Client()
user_michu = create_user('passwordmichu', 'michu')
create_user('passwordimmobile', 'immobile')
client.login(username='******', password='******')
# Create the Collection for the achievement NumSolvedCollectionAchievementDefinition and Problem
coll = create_collection('Coleccion de cartas')
# Create PodiumAchievementDefinition
ach_podium = PodiumAchievementDefinition(name='Presidente del podio', description='Consigue ser el primero',
num_problems=1, position=1)
ach_podium.save()
# Create NumSolvedCollectionAchievementDefinition
ach_collection = NumSolvedCollectionAchievementDefinition(name='Coleccionista', description='Resuelve 50\
problemas de esta coleccion', num_problems=50,
collection=coll)
ach_collection.save()
# Create NumSolvedAchievementDefinition
ach_solved = NumSolvedAchievementDefinition(name='Resolvista', description='Resuelve 50 problemas',
num_problems=50)
ach_solved.save()
# Create NumSolvedTypeAchievementDefinition
ach_type = NumSolvedTypeAchievementDefinition(name='Procedista', description='Resuelve un problema PROC',
num_problems=1, problem_type=ProblemType.PROC.name)
ach_type.save()
# Create NumSubmissionsProblemsAchievementDefinition
ach_submi_pro = NumSubmissionsProblemsAchievementDefinition(name='Muchos envios',
description='Envia muchas soluciones',
num_submissions=80, num_problems=1)
ach_submi_pro.save()
# Create problem and submit correct answer with "immobile" user, for make this the first to solve the problem
problem = create_select_problem(coll, 'Problema')
submit_select_url = reverse('judge:submit', args=[problem.pk])
client.post(submit_select_url, {'code': problem.solution}, follow=True)
client.logout()
# Login with "michu" and submit correct answer. All the checks will be with this user
client.login(username='******', password='******')
client.post(submit_select_url, {'code': problem.solution}, follow=True)
# Whit this definitions our user "michu" don't have any achievement
self.assertEqual(ObtainedAchievement.objects.filter(user=user_michu).count(), 0)
# PodiumAchievementDefinition now only need to stay in podium
# In this test our user "michu" stay at second position, that is why before he didn't have the achievement
ach_podium.position = 3
ach_podium.save()
# NumSolvedCollectionAchievementDefinition only needs one correct submission
# In this test our user only have one correct submission, that is why before he didn't have the achievement
ach_collection.num_problems = 1
ach_collection.save()
# NumSolvedAchievementDefinition only needs one correct submission
# In this test our user only have one correct submission, that is why before he didn't have the achievement
ach_solved.num_problems = 1
ach_solved.save()
# NumSolvedTypeAchievementDefinition change to type SELECT
# In this test our user only resolved a SELECT type problem, not PROC.
ach_type.problem_type = ProblemType.SELECT.name
ach_type.save()
# NumSubmissionsProblemsAchievementDefinition only needs one submission now
ach_submi_pro.num_submissions = 1
ach_submi_pro.save()
# Now our user "michu" have 5 achievements
self.assertEqual(ObtainedAchievement.objects.filter(user=user_michu).count(), 5)
def test_all_submissions(self):
""" Test the list [epoch, count] for different types of verdicts and days, and also the counter of submissions
"""
collection = create_collection('Test for statistics')
problem = create_select_problem(collection, 'Dummy for statistics')
user1 = create_user('0000', 'ana')
user2 = create_user('0000', 'juan')
subs = [
Submission(veredict_code=VeredictCode.AC, user=user1, problem=problem),
Submission(veredict_code=VeredictCode.WA, user=user2, problem=problem),
Submission(veredict_code=VeredictCode.RE, user=user2, problem=problem),
Submission(veredict_code=VeredictCode.TLE, user=user2, problem=problem),
Submission(veredict_code=VeredictCode.VE, user=user1, problem=problem),
Submission(veredict_code=VeredictCode.AC, user=user2, problem=problem),
]
dates = [
datetime(2020, 2, 12, 0, 0, 0, 0, tzinfo=pytz.utc),
datetime(2020, 2, 12, 0, 0, 0, 0, tzinfo=pytz.utc),
datetime(2020, 2, 15, 0, 0, 0, 0, tzinfo=pytz.utc),
datetime(2020, 2, 15, 0, 0, 0, 0, tzinfo=pytz.utc),
datetime(2020, 2, 16, 0, 0, 0, 0, tzinfo=pytz.utc),
datetime(2020, 2, 20, 0, 0, 0, 0, tzinfo=pytz.utc),
]
dates_epoch_ms = [int(date.timestamp()) * 1000 for date in dates]
for (sub, date) in zip(subs, dates):
sub.save()
sub.creation_date = date
sub.save() # Overwrites date, because it is automatically set to 'now' in the first save
count_all = submissions_by_day()
self.assertEqual(len(count_all), (dates[-1] - dates[0]).days + 1) # 9 days between first and last submission
self.assertEqual(count_all[0], [dates_epoch_ms[0], 2]) # 2 submissions on 1st day (2020-2-12)
self.assertEqual(count_all[1][1], 0) # 0 submissions on 2nd day
self.assertEqual(count_all[2][1], 0) # 0 submissions on 3rd day
self.assertEqual(count_all[3], [dates_epoch_ms[2], 2]) # 2 submissions on 4th day (2020-2-15)
self.assertEqual(count_all[4], [dates_epoch_ms[4], 1]) # 1 submission on 5th day (2020-2-16)
self.assertEqual(count_all[6][1], 0) # 0 submissions on 3rd day
self.assertEqual(count_all[8], [dates_epoch_ms[5], 1]) # 1 submission on 9th day (2020-2-20)
count_ac = submissions_by_day(verdict_code=VeredictCode.AC)
self.assertEqual(len(count_ac), (dates[-1] - dates[0]).days + 1) # 9 days between first and last AC submission
self.assertEqual(count_ac[0], [dates_epoch_ms[0], 1]) # 1 AC submissions on 1st day (2020-2-12)
self.assertEqual(count_ac[1][1], 0) # 0 submissions on 2nd day
self.assertEqual(count_ac[4][1], 0) # 0 submission on 5th day (2020-2-16)
self.assertEqual(count_ac[8], [dates_epoch_ms[5], 1]) # 1 submission on 9th day (2020-2-20)
count_wa = submissions_by_day(verdict_code=VeredictCode.WA)
self.assertEqual(len(count_wa), 1) # Only one entry
count_wa = submissions_by_day(verdict_code=VeredictCode.WA, start=dates_epoch_ms[0], end=dates_epoch_ms[-1])
self.assertEqual(len(count_wa), (dates[-1] - dates[0]).days + 1) # 9 days when forcing the start-end
count_re = submissions_by_day(verdict_code=VeredictCode.RE)
self.assertEqual(len(count_re), 1) # Only one entry
count_re = submissions_by_day(verdict_code=VeredictCode.RE, start=dates_epoch_ms[0], end=dates_epoch_ms[-1])
self.assertEqual(len(count_re), (dates[-1] - dates[0]).days + 1) # 9 days when forcing the start-end
self.assertEqual(count_re[0], [dates_epoch_ms[0], 0]) # 0 RE submissions on 1st day (2020-2-12)
self.assertEqual(count_re[3], [dates_epoch_ms[2], 1]) # 1 submissions on 4th day
self.assertEqual(count_re[8], [dates_epoch_ms[5], 0]) # 0 RE submission on 9th day (2020-2-20)
# Test the counter of submissions
sub_count = submission_count()
self.assertEqual(sub_count['all'], 6)
self.assertEqual(sub_count[VeredictCode.AC], 2)
self.assertEqual(sub_count[VeredictCode.WA], 1)
self.assertEqual(sub_count[VeredictCode.RE], 1)
self.assertEqual(sub_count[VeredictCode.TLE], 1)
self.assertEqual(sub_count[VeredictCode.VE], 1)
self.assertEqual(sub_count[VeredictCode.IE], 0)
def test_achievement_language(self):
"""Test to check the correct language display of achievements"""
client = Client()
solved_achievement_1 = NumSolvedAchievementDefinition(
name={
"es": 'Nombre1',
"en": 'Name1'
},
description={
"es": 'Descripción1',
"en": 'Description1'
},
num_problems=1)
solved_achievement_2 = NumSolvedAchievementDefinition(
name={
"es": 'Nombre2',
"en": 'Name2'
},
description={
"es": 'Descripción2',
"en": 'Description2'
},
num_problems=2)
solved_achievement_3 = NumSolvedAchievementDefinition(
name={"es": 'Nombre3'},
description={"es": 'Descripción3'},
num_problems=3)
solved_achievement_1.save()
solved_achievement_2.save()
solved_achievement_3.save()
coll = create_collection('Achievements')
problem = create_select_problem(coll, 'Select1')
user = create_user('5555', 'pepe')
client.login(username='******', password='******')
submit_select_url = reverse('judge:submit', args=[problem.pk])
client.post(submit_select_url, {'code': problem.solution}, follow=True)
client.post(submit_select_url, {'code': problem.solution}, follow=True)
client.cookies.load({settings.LANGUAGE_COOKIE_NAME: 'en'})
achievements_url = reverse('judge:achievements', args=[user.pk])
response = client.get(achievements_url, follow=True)
self.assertIn('Date', response.content.decode('utf-8'))
self.assertIn('Pending achievements', response.content.decode('utf-8'))
self.assertIn('Name1', response.content.decode('utf-8'))
self.assertIn('Name2', response.content.decode('utf-8'))
self.assertIn('Nombre3', response.content.decode('utf-8'))
self.assertIn('Description1', response.content.decode('utf-8'))
self.assertIn('Description2', response.content.decode('utf-8'))
self.assertIn('Descripción3', response.content.decode('utf-8'))
client.cookies.load({settings.LANGUAGE_COOKIE_NAME: 'es'})
achievements_url = reverse('judge:achievements', args=[user.pk])
response = client.get(achievements_url, follow=True)
self.assertIn('Fecha', response.content.decode('utf-8'))
self.assertIn('Logros pendientes', response.content.decode('utf-8'))
self.assertIn('Nombre1', response.content.decode('utf-8'))
self.assertIn('Nombre2', response.content.decode('utf-8'))
self.assertIn('Nombre3', response.content.decode('utf-8'))
self.assertIn('Descripción1', response.content.decode('utf-8'))
self.assertIn('Descripción2', response.content.decode('utf-8'))
self.assertIn('Descripción3', response.content.decode('utf-8'))
def test_collection_languages(self):
"""Test to check languages in collection list"""
client = Client()
collection = create_collection('Collection')
create_user('5555', 'pepe')
client.login(username='******', password='******')
create = 'CREATE TABLE mytable (dd DATE);'
insert = "INSERT INTO mytable VALUES (TO_DATE('2020/01/31', 'yyyy/mm/dd'))"
solution = 'SELECT * FROM mytable'
problem1 = SelectProblem(title_md='Dates',
text_md='Example with dates',
language="es",
create_sql=create,
insert_sql=insert,
collection=collection,
solution=solution)
problem2 = SelectProblem(title_md='Dates',
text_md='Example with dates',
language="es",
create_sql=create,
insert_sql=insert,
collection=collection,
solution=solution)
problem1.clean()
problem1.save()
problem2.clean()
problem2.save()
self.assertIn("es", collection.languages())
self.assertNotIn("en", collection.languages())
collections_url = reverse('judge:collections')
html = client.get(collections_url, follow=True).content.decode('utf-8')
soup = BeautifulSoup(html, 'html.parser')
self.assertEqual(
soup.find_all("div", {"class": "flags"})[0].find_all(
"span", {"flag-icon"}), [])
problem3 = SelectProblem(title_md='Dates',
text_md='Example with dates',
language="en",
create_sql=create,
insert_sql=insert,
collection=collection,
solution=solution)
problem3.clean()
problem3.save()
self.assertIn("es", collection.languages())
self.assertIn("en", collection.languages())
collections_url = reverse('judge:collections')
html = client.get(collections_url, follow=True).content.decode('utf-8')
soup = BeautifulSoup(html, 'html.parser')
self.assertEqual(
len(
soup.find_all("div", {"class": "flags"})[0].find_all(
"span", {"flag-icon"})), 2)
flags = soup.find_all("div", {"class": "flags"})[0].find_all(
"span", {"flag-icon"})[0]['class']
flags.extend(
soup.find_all("div", {"class": "flags"})[0].find_all(
"span", {"flag-icon"})[1]['class'])
self.assertIn("flag-icon-us", flags)
self.assertIn("flag-icon-es", flags)
def test_feedback_language(self):
"""Test to check language in feedback"""
client = Client()
collection = create_collection('Colleccion de prueba XYZ')
select_problem = create_select_problem(collection,
'SelectProblem ABC DEF')
create_user('5555', 'pedro')
client.login(username='******', password='******')
expected = {
'header': [['Algo', "<class 'cx_Oracle.NUMBER'>"],
['name', "<class 'cx_Oracle.STRING'>"]],
'rows': [[1, 'a'], [2, 'b']]
}
obtained1 = {
'header': [['name', "<class 'cx_Oracle.STRING'>"],
['Algo', "<class 'cx_Oracle.NUMBER'>"]],
'rows': [['b', 2], ['a', 1]]
}
obtained2 = {
'header': [['Algo', "<class 'cx_Oracle.NUMBER'>"],
['name', "<class 'cx_Oracle.STRING'>"],
['name', "<class 'cx_Oracle.STRING'>"]],
'rows': [[1, 'a', 'a'], [2, 'b', 'b']]
}
select_problem = create_select_problem(collection,
'SelectProblem ABC DEF')
client.cookies.load({settings.LANGUAGE_COOKIE_NAME: 'en'})
submit_url_select = reverse('judge:submit', args=[select_problem.pk])
response = client.post(
submit_url_select,
{'code': f'{select_problem.solution}; {select_problem.solution}'},
follow=True)
self.assertIn('Exactly expected 1 SQL statement',
response.content.decode('utf-8'))
self.assertIn("Expected: 2 columns",
compare_select_results(expected, obtained2, True)[1])
self.assertIn("Generated by your SQL code: 3 columns",
compare_select_results(expected, obtained2, True)[1])
self.assertIn("Number of columns obtained:",
compare_select_results(expected, obtained2, True)[1])
self.assertIn("name of the 1th column",
compare_select_results(expected, obtained1, False)[1])
self.assertIn("Expected name: Algo",
compare_select_results(expected, obtained1, False)[1])
self.assertIn("Generated name by your SQL code: name",
compare_select_results(expected, obtained1, False)[1])
client.cookies.load({settings.LANGUAGE_COOKIE_NAME: 'es'})
submit_url_select = reverse('judge:submit', args=[select_problem.pk])
response = client.post(
submit_url_select,
{'code': f'{select_problem.solution}; {select_problem.solution}'},
follow=True)
self.assertIn('Se esperaba exactamente 1 sentencia SQL',
response.content.decode('utf-8'))
self.assertIn("Esperado: 2 columnas",
compare_select_results(expected, obtained2, True)[1])
self.assertIn("Generado por tu código SQL: 3 columnas",
compare_select_results(expected, obtained2, True)[1])
self.assertIn("Número de columnas obtenidas:",
compare_select_results(expected, obtained2, True)[1])
self.assertIn("nombre de la 1ª columna",
compare_select_results(expected, obtained1, False)[1])
self.assertIn("Nombre esperado: Algo",
compare_select_results(expected, obtained1, False)[1])
self.assertIn("Nombre generado por tu código SQL: name",
compare_select_results(expected, obtained1, False)[1])
def test_compile_error(self):
"""Submitting code for a function/procedure/trigger with a compile error does resturn a
OracleStatusCode.COMPILATION_ERROR"""
curr_path = os.path.dirname(__file__)
zip_function_path = os.path.join(curr_path, ParseTest.ZIP_FOLDER,
ParseTest.FUNCTION_OK)
zip_proc_path = os.path.join(curr_path, ParseTest.ZIP_FOLDER,
ParseTest.PROC_OK)
zip_trigger_path = os.path.join(curr_path, ParseTest.ZIP_FOLDER,
ParseTest.TRIGGER_OK)
client = Client()
collection = create_collection('Colleccion de prueba AAA')
user = create_user('54522', 'antonio')
client.login(username='******', password='******')
function_problem = FunctionProblem(zipfile=zip_function_path,
collection=collection,
author=user)
proc_problem = ProcProblem(zipfile=zip_proc_path,
collection=collection,
author=user)
trigger_problem = TriggerProblem(zipfile=zip_trigger_path,
collection=collection,
author=user)
funct_compile_error = """
CREATE OR REPLACE FUNCTION golesLocal(resultado VARCHAR2) RETURN NUMBER IS
posGuion NUMBER;
golesStr VARCHAR2(3);
BEGIN
posGuion := INSTR(resultado, '-') -- Missing ';'
golesStr := SUBSTR(resultado, 0, posGuion - 1);
RETURN TO_NUMBER(golesStr);
END;"""
proc_compile_error = """
CREATE OR REPLACE PROCEDURE actualiza_socios(club_cif CHAR) IS
CURSOR cr_partidos IS SELECT CL.Nombre AS ClubL, CV.Nombre AS ClubV, COUNT(*) AS NAsistentes
FROM Enfrenta JOIN Asiste USING(CIF_local, CIF_visitante)
JOIN Club CL ON CL.CIF = CIF_Local
JOIN Club CV ON CV.CIF = CIF_visitante
WHERE CIF_local = club_cif OR CIF_visitante = club_cif
GROUP BY CIF_local, CIF_visitante, CL.Nombre, CV.Nombre;
incrPartido NUMBER;
incrTotal NUMBER := 0;
nPartido NUMBER := 1;
nombreClub VARCHAR2(200);
BEGIN
SELECT Nombre
INTO nombreClub
FROM Club
WHERE CIF = club_cif;
FOR partido IN cr_partidos LOOP
IF partido.NAsistentes > 3 THEN
incrPartido := 100;
ELSIF partido.NAsistentes > 1 -- Missing 'THEN'
incrPartido := 10;
ELSE
incrPartido := 0;
END IF;
incrTotal := incrTotal + incrPartido;
nPartido := nPartido + 1;
END LOOP;
UPDATE Club
SET Num_Socios = Num_Socios + incrTotal
WHERE CIF = club_cif;
END;"""
trigger_compile_error = """
CREATE OR REPLACE TRIGGER DispCantidadFinanciacion
BEFORE INSERT OR UPDATE
ON Financia FOR EACH ROW
DECLARE
numJug NUMBER;
BEGIN
SELECT COUNT(*) INTO numJug
FROM Jugador
WHERE CIF = :NEW.CIF_C;
IF numJug >= 2 THEN
:NEW.Cantidad := :NEW.Cantidad 1.25; -- Missing operator
END IF;
END;"""
for (problem, code) in [(function_problem, funct_compile_error),
(proc_problem, proc_compile_error),
(trigger_problem, trigger_compile_error)]:
problem.clean()
problem.save()
submit_url = reverse('judge:submit', args=[problem.pk])
response = client.post(submit_url, {'code': code}, follow=True)
self.assertEqual(response.json()['veredict'], VeredictCode.WA)
self.assertIn('error', response.json()['feedback'])
self.assertIn('compil', response.json()['feedback'])
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_achievements_submit(self):
"""Test to show correct message when obtain an achievement"""
client = Client()
collection = create_collection('Colleccion de prueba XYZ')
select_problem = create_select_problem(collection,
'SelectProblem ABC DEF')
user = create_user('5555', 'tamara')
ach_submission = NumSubmissionsProblemsAchievementDefinition(
name={"es": 'Un envio'},
description={"es": 'Envia una solucion para un problema'},
num_problems=1,
num_submissions=1)
ach_submission.save()
ach_submissions = NumSubmissionsProblemsAchievementDefinition(
name={"es": 'Tres envios'},
description={"es": 'Envia tres soluciones de un problema'},
num_problems=1,
num_submissions=3)
ach_submissions.save()
ach_type = NumSolvedTypeAchievementDefinition(
name={"es": 'Es select'},
description={"es": 'Resuelve un problema SELECT'},
num_problems=1,
problem_type=ProblemType.SELECT.name)
client.login(username='******', password='******')
submit_select_url = reverse('judge:submit', args=[select_problem.pk])
# The user submits one solution and obtains the first achievement
response = client.post(submit_select_url, {'code': 'MAL'},
follow=True) # Validation Error, too short
obtained_achieve = ObtainedAchievement.objects.filter(user=user)
self.assertIn(obtained_achieve[0].achievement_definition.name['es'],
response.json()['achievements'])
# The user submits a new solution and does not receive any achievement
response = client.post(submit_select_url, {'code': 'MAL'},
follow=True) # Validation Error, too short
self.assertNotIn('achievements', response.json())
# The user makes another submission and obtain two achievements
ach_type.save()
curr_path = os.path.dirname(__file__)
zip_select_path = os.path.join(curr_path, ParseTest.ZIP_FOLDER,
ParseTest.SELECT_OK)
collection = create_collection('Coleccion 1')
select = SelectProblem(zipfile=zip_select_path, collection=collection)
select.clean()
select.save()
submit_url = reverse('judge:submit', args=[select.pk])
response = client.post(submit_url, {'code': select.solution},
follow=True)
obtained_achieve = ObtainedAchievement.objects.filter(user=user)
self.assertIn(obtained_achieve[1].achievement_definition.name['es'],
response.json()['achievements'])
self.assertIn(obtained_achieve[2].achievement_definition.name['es'],
response.json()['achievements'])
# The user submits a new solution and does not receive any achievement
response = client.post(submit_select_url, {'code': 'MAL'},
follow=True) # Validation Error, too short
self.assertNotIn('achievements', response.json())
