def test_list_project_download_tasks(self):
# All admins should be able to see all download tasks.
user1, user2 = obj_build.make_admin_users(self.project.course, 2)
task1 = ag_models.DownloadTask.objects.validate_and_create(
project=self.project,
creator=user1,
download_type=ag_models.DownloadType.all_scores)
task2 = ag_models.DownloadTask.objects.validate_and_create(
project=self.project,
creator=user2,
download_type=ag_models.DownloadType.final_graded_submission_files)
other_project = obj_build.build_project()
ag_models.DownloadTask.objects.validate_and_create(
project=other_project,
creator=obj_build.make_admin_users(self.project.course, 1)[0],
download_type=ag_models.DownloadType.all_scores)
url = reverse('project-download-tasks', kwargs={'pk': self.project.pk})
self.client.force_authenticate(user1)
response = self.client.get(url)
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertCountEqual(
[task1.to_dict(), task2.to_dict()], response.data)
def test_admin_valid_create(self):
[admin] = obj_build.make_admin_users(self.course, 1)
data = {
'name': 'adsjkfa;jeifae;fjakjxc,mcaj'
}
self.do_create_object_test(
ag_models.AGTestCase.objects, self.client, admin, self.url, data)
def test_admin_update_bad_values(self):
bad_data = {
'name': ''
}
[admin] = obj_build.make_admin_users(self.course, 1)
self.do_patch_object_invalid_args_test(
self.ag_test_case, self.client, admin, self.url, bad_data)
def test_groups_sorted_by_least_alphabetical_username(self):
self.maxDiff = None
project = obj_build.make_project(max_group_size=3,
guests_can_submit=True)
[admin] = obj_build.make_admin_users(project.course, 1)
group1_user1 = User.objects.create(username='******')
group1 = ag_models.Group.objects.validate_and_create(
members=[group1_user1], project=project)
group2_user1 = User.objects.create(username='******')
group2_user2 = User.objects.create(username='******')
group2 = ag_models.Group.objects.validate_and_create(
members=[group2_user1, group2_user2], project=project)
group3_user1 = User.objects.create(username='******')
group3_user2 = User.objects.create(username='******')
group3_user3 = User.objects.create(username='******')
group3 = ag_models.Group.objects.validate_and_create(
members=[group3_user1, group3_user2, group3_user3],
project=project)
expected = [group2.to_dict(),
group3.to_dict(),
group1.to_dict()] # type: List[dict]
for group_dict in expected:
group_dict['member_names'] = list(
sorted(group_dict['member_names']))
self.client.force_authenticate(admin)
response = self.client.get(
reverse('groups', kwargs={'project_pk': project.pk}))
self.assertEqual(expected, response.data)
def test_admin_or_staff_or_handgrader_valid_create(self):
[admin] = obj_build.make_admin_users(self.course, 1)
[handgrader] = obj_build.make_handgrader_users(self.course, 1)
[staff] = obj_build.make_staff_users(self.course, 1)
for user in admin, handgrader, staff:
response = self.do_create_object_test(
handgrading_models.AppliedAnnotation.objects,
self.client,
user,
self.url,
self.data,
check_data=False)
loaded = handgrading_models.AppliedAnnotation.objects.get(
pk=response.data['pk'])
self.assert_dict_contents_equal(loaded.to_dict(), response.data)
annotation = handgrading_models.Annotation.objects.get(
pk=self.data['annotation'])
self.assertEqual(annotation.to_dict(), loaded.annotation.to_dict())
response_location_dict = loaded.location.to_dict()
for non_modifiable in ["pk", "last_modified"]:
response_location_dict.pop(non_modifiable)
self.assertEqual(self.data["location"], response_location_dict)
def test_copy_course(self):
proj1 = obj_build.make_project()
course = proj1.course
proj2 = obj_build.make_project(course)
admins = obj_build.make_admin_users(course, 4)
staff = obj_build.make_staff_users(course, 3)
students = obj_build.make_student_users(course, 5)
handgraders = obj_build.make_handgrader_users(course, 2)
self.assertNotEqual(0, course.staff.count())
self.assertNotEqual(0, course.students.count())
self.assertNotEqual(0, course.handgraders.count())
name = 'stove'
new_course = copy_course(course, name, Semester.summer, 2019)
self.assertEqual(name, new_course.name)
self.assertEqual(Semester.summer, new_course.semester)
self.assertEqual(2019, new_course.year)
self.assertCountEqual(admins, new_course.admins.all())
self.assertSequenceEqual([], new_course.staff.all())
self.assertSequenceEqual([], new_course.students.all())
self.assertSequenceEqual([], new_course.handgraders.all())
old_project_pks = {proj.pk for proj in course.projects.all()}
new_project_pks = {proj.pk for proj in new_course.projects.all()}
self.assertTrue(old_project_pks.isdisjoint(new_project_pks))
self.assertSetEqual({proj.name
for proj in course.projects.all()},
{proj.name
for proj in new_course.projects.all()})
def setUp(self):
super().setUp()
self.group = obj_build.make_group()
self.student = self.group.members.first()
self.project = self.group.project
ag_models.ExpectedStudentFile.objects.validate_and_create(
pattern='*', max_num_matches=10, project=self.project)
self.submitted_files = [SimpleUploadedFile('file{}'.format(i),
'waaaluigi{}'.format(i).encode())
for i in range(3)]
self.submission = obj_build.make_submission(
group=self.group,
submitted_files=self.submitted_files,
status=Submission.GradingStatus.finished_grading)
self.handgrading_rubric = hg_models.HandgradingRubric.objects.validate_and_create(
project=self.project
) # type: hg_models.HandgradingRubric
[self.admin] = obj_build.make_admin_users(self.project.course, 1)
[self.staff] = obj_build.make_staff_users(self.project.course, 1)
[self.handgrader] = obj_build.make_users(1)
self.project.course.handgraders.add(self.handgrader)
self.client = APIClient()
self.course = self.handgrading_rubric.project.course
self.url = reverse('handgrading_result',
kwargs={'group_pk': self.submission.group.pk})
def test_admin_update_bad_values(self):
bad_data = {
"deduction": 42,
}
[admin] = obj_build.make_admin_users(self.course, 1)
self.do_patch_object_invalid_args_test(self.annotation, self.client,
admin, self.url, bad_data)
def test_admin_or_staff_or_handgrader_valid_get(self):
[admin] = obj_build.make_admin_users(self.course, 1)
[staff] = obj_build.make_staff_users(self.course, 1)
[handgrader] = obj_build.make_handgrader_users(self.course, 1)
for user in admin, staff, handgrader:
self.do_get_object_test(self.client, user, self.url,
self.applied_annotation.to_dict())
def test_admin_user_roles(self):
[admin] = obj_build.make_admin_users(self.course, 1)
expected = self.expected_response_base()
expected['is_admin'] = True
expected['is_staff'] = True
self.do_get_object_test(self.client, admin, self.url, expected)
def test_admin_valid_create(self):
[admin] = obj_build.make_admin_users(self.course, 1)
data = {
'name': 'qpweiourasdjf',
'cmd': 'echo "haldo"',
}
self.do_create_object_test(
ag_models.AGTestCommand.objects, self.client, admin, self.url, data)
def test_admin_set_order(self):
[admin] = obj_build.make_admin_users(self.course, 1)
self.client.force_authenticate(admin)
reverse_order = self.ag_test_case.get_agtestcommand_order()[::-1]
response = self.client.put(self.url, reverse_order)
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertSequenceEqual(reverse_order, response.data)
def test_admin_set_order(self):
[admin] = obj_build.make_admin_users(self.course, 1)
self.client.force_authenticate(admin)
reverse_order = self.handgrading_rubric.get_criterion_order()[::-1]
response = self.client.put(self.url, reverse_order)
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertSequenceEqual(reverse_order, self.handgrading_rubric.get_criterion_order())
def test_admin_or_staff_valid_create_without_location(self):
[admin] = obj_build.make_admin_users(self.course, 1)
[staff] = obj_build.make_staff_users(self.course, 1)
data = {"text": "Sample comment text."}
for user in admin, staff:
self.do_create_object_test(handgrading_models.Comment.objects,
self.client, user, self.url, data)
def test_admin_update_bad_values(self):
bad_data = {
'points_style': 'incorrect_enum_field',
'max_points': -10,
}
[admin] = obj_build.make_admin_users(self.course, 1)
self.do_patch_object_invalid_args_test(self.handgrading_rubric,
self.client, admin, self.url,
bad_data)
def test_admin_update_bad_values(self):
bad_data = {
"points": "something_wrong",
"long_description": 12,
"short_description": 12,
}
[admin] = obj_build.make_admin_users(self.course, 1)
self.do_patch_object_invalid_args_test(
self.criterion, self.client, admin, self.url, bad_data)
def test_admin_valid_update(self):
patch_data = {
"short_description": "Changing short description.",
"long_description": "Changing loooooooong description.",
"points": 40,
}
[admin] = obj_build.make_admin_users(self.course, 1)
self.do_patch_object_test(
self.criterion, self.client, admin, self.url, patch_data)
def test_admin_valid_update(self):
[admin] = obj_build.make_admin_users(self.course, 1)
patch_data = {
'name': 'mcnaieoa;dk',
'normal_fdbk_config': {
'return_code_fdbk_level': ag_models.ValueFeedbackLevel.expected_and_actual.value
}
}
self.do_patch_object_test(self.ag_test_cmd, self.client, admin, self.url, patch_data)
def test_admin_update_bad_values(self):
[admin] = obj_build.make_admin_users(self.course, 1)
bad_patch_data = {
'normal_fdbk_config': {
'return_code_fdbk_level': 'not_a_value'
}
}
self.do_patch_object_invalid_args_test(
self.ag_test_cmd, self.client, admin, self.url, bad_patch_data)
def test_admin_set_order(self):
[admin] = obj_build.make_admin_users(self.project.course, 1)
self.client.force_authenticate(admin)
reverse_order = self.project.get_studenttestsuite_order()[::-1]
response = self.client.put(self.url, reverse_order)
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertSequenceEqual(reverse_order,
self.project.get_studenttestsuite_order())
def setUp(self):
super().setUp()
self.course = obj_build.make_course()
self.client = APIClient()
self.url = reverse('course-staff', kwargs={'pk': self.course.pk})
[self.admin] = obj_build.make_admin_users(self.course, 1)
[self.student] = obj_build.make_student_users(self.course, 1)
[self.guest] = obj_build.make_users(1)
[self.handgrader] = obj_build.make_handgrader_users(self.course, 1)
def test_admin_update_bad_values(self):
patch_data = {
'name': '',
'ultimate_submission_fdbk_config': {
'not_a_field': False
}
}
[admin] = obj_build.make_admin_users(self.course, 1)
self.do_patch_object_invalid_args_test(self.ag_test_suite, self.client,
admin, self.url, patch_data)
def test_create_criterion_results_on_create(self):
[admin] = obj_build.make_admin_users(self.course, 1)
self.client.force_authenticate(admin)
# Create HandgradingResult
submission = obj_build.make_submission(
group=obj_build.make_group(project=self.handgrading_rubric.project))
handgrading_result = hg_models.HandgradingResult.objects.validate_and_create(
submission=submission,
group=submission.group,
handgrading_rubric=self.handgrading_rubric)
# Create dummy submissions and groups with no submissions. These should not be affected
dummy_submission = obj_build.make_submission(
group=obj_build.make_group(project=self.handgrading_rubric.project))
dummy_submission = obj_build.make_submission(
group=obj_build.make_group(project=self.handgrading_rubric.project))
group_with_no_submission = obj_build.make_group(project=self.handgrading_rubric.project)
group_with_no_submission = obj_build.make_group(project=self.handgrading_rubric.project)
self.assertEqual(0, handgrading_result.criterion_results.count())
self.assertEqual(1, hg_models.HandgradingResult.objects.count())
# Create dummy project with its own groups and HandgradingResults.
# These should not be affected
dummy_project = obj_build.make_project(course=self.handgrading_rubric.project.course)
dummy_handgrading_rubric = hg_models.HandgradingRubric.objects.validate_and_create(
points_style=hg_models.PointsStyle.start_at_max_and_subtract,
max_points=0,
show_grades_and_rubric_to_students=False,
handgraders_can_leave_comments=True,
handgraders_can_adjust_points=True,
project=dummy_project)
dummy_submission = obj_build.make_submission(
group=obj_build.make_group(project=self.handgrading_rubric.project))
dummy_handgrading_result = hg_models.HandgradingResult.objects.validate_and_create(
submission=dummy_submission,
group=dummy_submission.group,
handgrading_rubric=dummy_handgrading_rubric)
self.assertEqual(0, hg_models.CriterionResult.objects.count())
self.assertEqual(2, hg_models.HandgradingResult.objects.count())
# Create Criterion, which should create a CriterionResult for above HandgradingResult
response = self.client.post(self.url, self.data)
self.assertEqual(status.HTTP_201_CREATED, response.status_code)
handgrading_result.refresh_from_db()
self.assertEqual(1, handgrading_result.criterion_results.count())
self.assertEqual(1, hg_models.CriterionResult.objects.count())
criterion_results = handgrading_result.to_dict()["criterion_results"]
self.assertFalse(criterion_results[0]["selected"])
self.assertEqual(criterion_results[0]["criterion"], response.data)
def test_admin_valid_update(self):
patch_data = {
'points_style': 'start_at_max_and_subtract',
'max_points': 10,
'show_grades_and_rubric_to_students': False,
'handgraders_can_leave_comments': False,
'handgraders_can_adjust_points': False
}
[admin] = obj_build.make_admin_users(self.course, 1)
self.do_patch_object_test(self.handgrading_rubric, self.client, admin,
self.url, patch_data)
def test_admin_or_staff_or_handgrader_valid_list_comments(self):
[admin] = obj_build.make_admin_users(self.course, 1)
[staff] = obj_build.make_staff_users(self.course, 1)
[handgrader] = obj_build.make_handgrader_users(self.course, 1)
for user in admin, handgrader, staff:
self.client.force_authenticate(user)
response = self.client.get(self.url)
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertSequenceEqual(self.comment.to_dict(), response.data[0])
def test_admin_valid_update(self):
other_suite = obj_build.make_ag_test_suite(project=self.ag_test_case.ag_test_suite.project)
patch_data = {
'name': 'ncvai',
'ag_test_suite': other_suite.pk,
'normal_fdbk_config': {
'show_individual_commands': False
}
}
[admin] = obj_build.make_admin_users(self.course, 1)
self.do_patch_object_test(self.ag_test_case, self.client, admin, self.url, patch_data)
def test_admin_valid_update(self):
patch_data = {
'name': 'a new name',
'buggy_impl_names': ['bug_spam', 'bug_egg']
}
[admin] = obj_build.make_admin_users(self.course, 1)
response = self.do_patch_object_test(self.student_suite, self.client,
admin, self.url, patch_data)
# Make sure the DecimalField is encoded correctly.
self.assertIsInstance(response.data['points_per_exposed_bug'], str)
def test_admin_valid_update(self):
patch_data = {
'name': 'asdf;aliena,cskvnaksd;fasdkjfaklsd',
'setup_suite_cmd': 'echo "weeeeeeeeee"',
'ultimate_submission_fdbk_config': {
'show_setup_stderr': False
},
'deferred': True
}
[admin] = obj_build.make_admin_users(self.course, 1)
self.do_patch_object_test(self.ag_test_suite, self.client, admin,
self.url, patch_data)
def setUp(self):
super().setUp()
self.project = obj_build.make_project()
[self.creator] = obj_build.make_admin_users(self.project.course, 1)
self.ag_test_suite = obj_build.make_ag_test_suite(self.project)
self.ag_test_case = obj_build.make_ag_test_case(self.ag_test_suite)
self.student_test_suite = obj_build.make_student_test_suite(
self.project)
self.submission = obj_build.make_submission(group=obj_build.make_group(
project=self.project))
def test_admin_or_staff_or_handgrader_update_bad_values(self):
bad_data = {
"location": "Not an editable field!",
}
[admin] = obj_build.make_admin_users(self.course, 1)
[handgrader] = obj_build.make_handgrader_users(self.course, 1)
[staff] = obj_build.make_staff_users(self.course, 1)
for user in admin, staff, handgrader:
self.do_patch_object_invalid_args_test(self.applied_annotation,
self.client, user, self.url,
bad_data)
