def test_error_non_unique_name(self):
course = obj_build.make_course()
with self.assertRaises(exceptions.ValidationError):
copy_course(course,
new_course_name=course.name,
new_course_semester=None,
new_course_year=None)
def test_admin_change_late_day_count_for_other_course_permission_denied(
self):
admin = obj_build.make_admin_user(self.course)
# Student for other course
other_course = obj_build.make_course()
other_course_student = obj_build.make_student_user(other_course)
self.assertFalse(other_course.is_admin(admin))
self.client.force_authenticate(admin)
response = self.client.put(
self.get_pk_url(other_course_student, other_course),
{'late_days_remaining': 10})
self.assertEqual(status.HTTP_403_FORBIDDEN, response.status_code)
response = self.client.put(
self.get_username_url(other_course_student, other_course),
{'late_days_remaining': 10})
self.assertEqual(status.HTTP_403_FORBIDDEN, response.status_code)
# Guest for other course
other_guest = obj_build.make_user()
response = self.client.put(self.get_pk_url(other_guest, other_course),
{'late_days_remaining': 7})
self.assertEqual(status.HTTP_403_FORBIDDEN, response.status_code)
other_guest = obj_build.make_user()
response = self.client.put(
self.get_username_url(other_guest, other_course),
{'late_days_remaining': 7})
self.assertEqual(status.HTTP_403_FORBIDDEN, response.status_code)
def test_staff_view_late_day_count_for_other_course_permission_denied(
self):
staff = obj_build.make_staff_user(self.course)
# Student for other course
other_course = obj_build.make_course()
other_course_student = obj_build.make_student_user(other_course)
self.assertFalse(other_course.is_staff(staff))
self.client.force_authenticate(staff)
response = self.client.get(
self.get_pk_url(other_course_student, other_course))
self.assertEqual(status.HTTP_403_FORBIDDEN, response.status_code)
response = self.client.get(
self.get_username_url(other_course_student, other_course))
self.assertEqual(status.HTTP_403_FORBIDDEN, response.status_code)
# Guest for other course
other_guest = obj_build.make_user()
response = self.client.get(self.get_pk_url(other_guest, other_course))
self.assertEqual(status.HTTP_403_FORBIDDEN, response.status_code)
response = self.client.get(
self.get_username_url(other_guest, other_course))
self.assertEqual(status.HTTP_403_FORBIDDEN, response.status_code)
def setUp(self):
super().setUp()
self.client = APIClient()
self.initial_num_late_days = 4
self.course = obj_build.make_course(
num_late_days=self.initial_num_late_days)
def test_is_admin(self):
self.course = obj_build.make_course()
self.user = obj_build.create_dummy_user()
self.assertFalse(self.course.is_admin(self.user))
self.course.admins.add(self.user)
self.assertTrue(self.course.is_admin(self.user))
def setUp(self):
super().setUp()
self.client = APIClient()
self.project = obj_build.make_project()
self.admin = obj_build.make_admin_user(self.project.course)
self.other_course = obj_build.make_course()
self.other_course.admins.add(self.admin)
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_get_course_by_pk(self):
course = obj_build.make_course()
[admin] = obj_build.make_admin_users(course, 1)
[guest] = obj_build.make_users(1)
for user in admin, guest:
self.client.force_authenticate(user)
response = self.client.get(
reverse('course-detail', kwargs={'pk': course.pk}))
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual(course.to_dict(), response.data)
def test_get_num_queued_submissions(self):
client = APIClient()
course = obj_build.make_course()
admin = obj_build.make_admin_user(course)
proj_kwargs = {'visible_to_students': True, 'guests_can_submit': True}
no_submits = obj_build.make_project(course, **proj_kwargs)
with_submits1 = obj_build.make_project(course, **proj_kwargs)
with_submits2 = obj_build.make_project(course, **proj_kwargs)
group_with_submits1 = obj_build.make_group(project=with_submits1)
group_with_submits2 = obj_build.make_group(project=with_submits2)
g1_statuses = [
ag_models.Submission.GradingStatus.queued,
ag_models.Submission.GradingStatus.finished_grading,
ag_models.Submission.GradingStatus.removed_from_queue,
ag_models.Submission.GradingStatus.received,
ag_models.Submission.GradingStatus.being_graded,
ag_models.Submission.GradingStatus.error
]
for grading_status in g1_statuses:
obj_build.make_submission(status=grading_status,
group=group_with_submits1)
for i in range(3):
obj_build.make_submission(
status=ag_models.Submission.GradingStatus.queued,
group=group_with_submits2)
client.force_authenticate(admin)
response = client.get(
reverse('project-num-queued-submissions',
kwargs={'pk': no_submits.pk}))
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual(0, response.data)
response = client.get(
reverse('project-num-queued-submissions',
kwargs={'pk': with_submits1.pk}))
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual(1, response.data)
response = client.get(
reverse('project-num-queued-submissions',
kwargs={'pk': with_submits2.pk}))
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual(3, response.data)
def test_invalid_semester(self):
course = obj_build.make_course(semester=ag_models.Semester.winter,
year=2019)
url = reverse('course-by-fields',
kwargs={
'name': course.name,
'semester': 'bad',
'year': course.year
})
guest = obj_build.make_user()
self.client.force_authenticate(guest)
response = self.client.get(url)
self.assertEqual(status.HTTP_400_BAD_REQUEST, response.status_code)
def setUp(self):
super().setUp()
self.maxDiff = None
self.client = APIClient()
self.course = obj_build.make_course()
self.project = obj_build.make_project(course=self.course)
self.assertEqual(ag_models.UltimateSubmissionPolicy.most_recent,
self.project.ultimate_submission_policy)
self.rubric = hg_models.HandgradingRubric.objects.validate_and_create(
project=self.project,
points_style=hg_models.PointsStyle.start_at_max_and_subtract,
max_points=43)
[self.staff] = obj_build.make_staff_users(self.course, 1)
[self.handgrader] = obj_build.make_handgrader_users(self.course, 1)
def test_get_course_by_name_semester_and_year(self):
course = obj_build.make_course(semester=ag_models.Semester.winter,
year=2019)
url = reverse('course-by-fields',
kwargs={
'name': course.name,
'semester': course.semester.value,
'year': course.year
})
guest = obj_build.make_user()
self.client.force_authenticate(guest)
response = self.client.get(url)
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual(course.to_dict(), response.data)
def test_serialization(self):
expected_fields = [
'pk',
'name',
'semester',
'year',
'subtitle',
'num_late_days',
'last_modified',
]
course = obj_build.make_course()
serialized = course.to_dict()
self.assertCountEqual(expected_fields, serialized.keys())
serialized.pop('pk')
serialized.pop('last_modified')
course.validate_and_update(**serialized)
def test_superuser_view_calls_copy_course(self):
superuser = obj_build.make_user(superuser=True)
dummy_course = obj_build.make_course()
mock_copy_course = mock.Mock(return_value=dummy_course)
with mock.patch(
'autograder.rest_api.views.course_views.course_views.copy_course',
new=mock_copy_course):
self.client.force_authenticate(superuser)
response = self.client.post(
reverse('copy-course', kwargs={'course_pk': self.course.pk}), {
'new_name': 'Clone',
'new_semester': ag_models.Semester.winter.value,
'new_year': 2020
})
mock_copy_course.assert_called_once_with(
course=self.course,
new_course_name='Clone',
new_course_semester=ag_models.Semester.winter,
new_course_year=2020)
def test_user_can_copy_course_and_is_admin_view_calls_copy_course(self):
user = obj_build.make_admin_user(self.course)
user.user_permissions.add(
Permission.objects.get(codename='create_course'))
dummy_course = obj_build.make_course()
mock_copy_course = mock.Mock(return_value=dummy_course)
with mock.patch(
'autograder.rest_api.views.course_views.course_views.copy_course',
new=mock_copy_course):
self.client.force_authenticate(user)
response = self.client.post(
reverse('copy-course', kwargs={'course_pk': self.course.pk}), {
'new_name': 'Cloney',
'new_semester': ag_models.Semester.spring.value,
'new_year': 2021
})
mock_copy_course.assert_called_once_with(
course=self.course,
new_course_name='Cloney',
new_course_semester=ag_models.Semester.spring,
new_course_year=2021)
def setUp(self):
super().setUp()
self.client = APIClient()
self.course = obj_build.make_course()
def setUp(self):
super().setUp()
self.course = obj_build.make_course()
self.user = obj_build.create_dummy_user()
def test_copy_project(self):
# In new project, hide_ultimate_submission_fdbk should be set to True,
# visible_to_students should be set to False,
# and guests_can_submit should be set to False
project = obj_build.make_project(hide_ultimate_submission_fdbk=False,
visible_to_students=True)
instructor_file1 = obj_build.make_instructor_file(project)
instructor_file2 = obj_build.make_instructor_file(project)
student_file1 = obj_build.make_expected_student_file(project)
student_file2 = obj_build.make_expected_student_file(project)
suite1 = obj_build.make_ag_test_suite(
project,
instructor_files_needed=[instructor_file1],
student_files_needed=[student_file1])
case1 = obj_build.make_ag_test_case(suite1)
cmd1 = obj_build.make_full_ag_test_command(
case1,
expected_stderr_source=ag_models.ExpectedOutputSource.
instructor_file,
expected_stderr_instructor_file=instructor_file2)
cmd2 = obj_build.make_full_ag_test_command(
case1,
set_arbitrary_points=False,
expected_stdout_source=ag_models.ExpectedOutputSource.
instructor_file,
expected_stdout_instructor_file=instructor_file1)
suite2 = obj_build.make_ag_test_suite(
project,
instructor_files_needed=[instructor_file1, instructor_file2],
student_files_needed=[student_file2])
case2 = obj_build.make_ag_test_case(suite2)
cmd3 = obj_build.make_full_ag_test_command(
case2,
set_arbitrary_expected_vals=False,
stdin_source=ag_models.StdinSource.instructor_file,
stdin_instructor_file=instructor_file2)
case3 = obj_build.make_ag_test_case(suite2)
suite3 = obj_build.make_ag_test_suite(project)
student_suite1 = obj_build.make_student_test_suite(
project,
instructor_files_needed=[instructor_file1, instructor_file2],
student_files_needed=[student_file1],
setup_command={
'name': 'stave',
'cmd': 'yorp'
})
student_suite2 = obj_build.make_student_test_suite(
project,
instructor_files_needed=[instructor_file1],
student_files_needed=[student_file1, student_file2])
student_suite3 = obj_build.make_student_test_suite(project)
other_course = obj_build.make_course()
new_project = copy_project(project, other_course)
self.assertTrue(new_project.hide_ultimate_submission_fdbk)
self.assertFalse(new_project.visible_to_students)
self.assertEqual(project.name, new_project.name)
self.assertEqual(other_course, new_project.course)
self.assertNotEqual(project.course, other_course)
ignore_fields = [
'pk', 'course', 'last_modified', 'instructor_files',
'expected_student_files'
]
expected_ag_tests = _pop_many(project.to_dict(), ignore_fields)
expected_ag_tests.update({
'visible_to_students': False,
'hide_ultimate_submission_fdbk': True
})
self.assertEqual(expected_ag_tests,
_pop_many(new_project.to_dict(), ignore_fields))
self.assertEqual(project.instructor_files.count(),
new_project.instructor_files.count())
for old_file, new_file in itertools.zip_longest(
sorted(project.instructor_files.all(),
key=lambda obj: obj.name),
sorted(new_project.instructor_files.all(),
key=lambda obj: obj.name)):
self.assertNotEqual(new_file.pk, old_file.pk)
self.assertNotEqual(new_file.abspath, old_file.abspath)
self.assertEqual(old_file.name, new_file.name)
with old_file.open() as old_f, new_file.open() as new_f:
self.assertEqual(old_f.read(), new_f.read())
self.assertEqual(project.expected_student_files.count(),
new_project.expected_student_files.count())
for old_expected_file, new_expected_file in itertools.zip_longest(
project.expected_student_files.order_by('pattern'),
new_project.expected_student_files.order_by('pattern')):
self.assertNotEqual(old_expected_file.pk, new_expected_file.pk)
self.assertEqual(
_pop_many(old_expected_file.to_dict(), ['pk', 'project']),
_pop_many(new_expected_file.to_dict(), ['pk', 'project']))
old_suite_pks = {suite.pk for suite in project.ag_test_suites.all()}
new_suite_pks = {
suite.pk
for suite in new_project.ag_test_suites.all()
}
self.assertTrue(old_suite_pks.isdisjoint(new_suite_pks))
old_case_pks = {
case.pk
for case in ag_models.AGTestCase.objects.filter(
ag_test_suite__project=project)
}
def setUp(self):
super().setUp()
self.client = APIClient()
self.course = obj_build.make_course()
self.url = reverse('projects', kwargs={'pk': self.course.pk})
def setUp(self):
super().setUp()
self.client = APIClient()
self.course = obj_build.make_course()
[self.guest] = obj_build.make_users(1)
def setUp(self):
super().setUp()
self.client = APIClient()
self.courses = [obj_build.make_course() for i in range(4)]
