def test_superuser_or_admin_add_admins(self):
current_admins = obj_build.create_dummy_users(2)
self.course.admins.add(*current_admins)
new_admin_names = ['steve', 'stave', 'stove', 'stive']
new_admins = obj_build.create_dummy_users(2)
for user in (self.superuser, current_admins[0]):
self.assertEqual(len(current_admins), self.course.admins.count())
self.client.force_authenticate(user)
response = self.client.post(
self.url, {
'new_admins':
new_admin_names + [user.username for user in new_admins]
})
self.assertEqual(status.HTTP_204_NO_CONTENT, response.status_code)
expected_usernames = list(
itertools.chain([user.username for user in current_admins],
new_admin_names,
[user.username for user in new_admins]))
self.assertCountEqual(
expected_usernames,
[admin.username for admin in self.course.admins.all()])
self.course.admins.set(current_admins, clear=True)
def setUp(self):
super().setUp()
self.remaining_students = obj_build.create_dummy_users(2)
self.students_to_remove = obj_build.create_dummy_users(5)
self.all_enrolled = self.remaining_students + self.students_to_remove
self.total_num_enrolled = len(self.all_enrolled)
self.course.students.add(*self.all_enrolled)
self.request_body = {
'remove_students':
ag_serializers.UserSerializer(self.students_to_remove, many=True).data
}
def setUp(self):
super().setUp()
self.remaining_handgraders = obj_build.create_dummy_users(2)
self.handgraders_to_remove = obj_build.create_dummy_users(5)
self.all_handgraders = self.remaining_handgraders + self.handgraders_to_remove
self.total_num_handgraders = len(self.all_handgraders)
self.course.handgraders.add(*self.all_handgraders)
self.request_body = {
"remove_handgraders":
ag_serializers.UserSerializer(self.handgraders_to_remove,
many=True).data
}
def get_legal_members(self):
if hasattr(self, '_legal_members'):
return self._legal_members
self.project.validate_and_update(max_group_size=3)
self._legal_members = obj_build.create_dummy_users(2)
self.project.course.students.add(*self._legal_members)
return self._legal_members
def test_admin_add_staff(self):
current_staff = obj_build.create_dummy_users(2)
self.course.staff.add(*current_staff)
new_staff_names = (
['staffy1', 'staffy2'] +
[user.username for user in obj_build.create_dummy_users(2)])
self.assertEqual(len(current_staff), self.course.staff.count())
self.client.force_authenticate(self.admin)
response = self.client.post(self.url, {'new_staff': new_staff_names})
self.assertEqual(status.HTTP_204_NO_CONTENT, response.status_code)
new_staff = list(User.objects.filter(username__in=new_staff_names))
self.assertCountEqual(current_staff + new_staff,
self.course.staff.all())
def test_admin_update_students(self):
new_roster = obj_build.create_dummy_users(3)
self.client.force_authenticate(self.admin)
response = self.client.put(
self.url,
{'new_students':
[user.username for user in new_roster]})
self.assertEqual(status.HTTP_204_NO_CONTENT, response.status_code)
self.assertCountEqual(new_roster, self.course.students.all())
def test_other_update_students_permission_denied(self):
for user in self.staff, self.current_students[0], self.guest:
self.client.force_authenticate(user)
response = self.client.put(
self.url,
{'new_students':
[user.username for user in obj_build.create_dummy_users(2)]})
self.assertEqual(status.HTTP_403_FORBIDDEN, response.status_code)
self.assertCountEqual(self.current_students,
self.course.students.all())
def test_valid_override_group_max_size(self):
self.student_users += obj_build.create_dummy_users(3)
self.project.course.students.add(*self.student_users)
group = ag_models.Group.objects.validate_and_create(
members=self.student_users,
project=self.project,
check_group_size_limits=False)
group.refresh_from_db()
self.assertCountEqual(self.student_users, group.members.all())
def test_serialize(self):
project = obj_build.build_project(project_kwargs={
'max_group_size': 5,
'guests_can_submit': True
})
invitation = ag_models.GroupInvitation.objects.validate_and_create(
obj_build.create_dummy_user(),
obj_build.create_dummy_users(2),
project=project)
self.do_basic_serialize_test(
invitation, ag_serializers.SubmissionGroupInvitationSerializer)
def test_update_group_error_too_many_members(self):
group = ag_models.Group.objects.validate_and_create(
members=self.student_users,
project=self.project)
new_members = obj_build.create_dummy_users(5)
self.project.course.students.add(*new_members)
with self.assertRaises(exceptions.ValidationError) as cm:
group.validate_and_update(members=new_members)
self.assertTrue('members' in cm.exception.message_dict)
def test_admin_or_staff_or_handgrader_list_staff(self):
staff = obj_build.create_dummy_users(3)
self.course.staff.add(*staff)
expected_content = ag_serializers.UserSerializer(staff, many=True).data
for user in self.admin, staff[0], self.handgrader:
self.client.force_authenticate(user)
response = self.client.get(self.url)
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertCountEqual(expected_content, response.data)
def setUp(self):
super().setUp()
self.remaining_admin = obj_build.create_dummy_user()
self.current_admins = obj_build.create_dummy_users(3)
self.all_admins = [self.remaining_admin] + self.current_admins
self.total_num_admins = len(self.all_admins)
self.course.admins.add(*self.all_admins)
self.request_body = {
'remove_admins':
ag_serializers.UserSerializer(self.current_admins, many=True).data
}
def setUp(self):
super().setUp()
self.remaining_staff = obj_build.create_dummy_user()
self.staff_to_remove = obj_build.create_dummy_users(3)
self.all_staff = [self.remaining_staff] + self.staff_to_remove
self.total_num_staff = len(self.all_staff)
self.course.staff.add(*self.all_staff)
self.request_body = {
'remove_staff':
ag_serializers.UserSerializer(self.staff_to_remove, many=True).data
}
def test_admin_add_students(self):
self.client.force_authenticate(self.admin)
new_student_names = (
['steve', 'bill'] + [user.username for user in obj_build.create_dummy_users(3)])
self.assertEqual(len(self.current_students), self.course.students.count())
response = self.client.post(self.url, {'new_students': new_student_names})
new_students = list(
User.objects.filter(username__in=new_student_names))
self.assertEqual(status.HTTP_204_NO_CONTENT, response.status_code)
self.assertCountEqual(new_students + self.current_students,
self.course.students.all())
def test_invalid_invitation_create_user_has_pending_invite_sent(self):
ag_models.GroupInvitation.objects.validate_and_create(
invited_users=self.to_invite,
invitation_creator=self.invitation_creator,
project=self.project)
other_invitees = obj_build.create_dummy_users(len(self.to_invite))
self.project.course.students.add(*other_invitees)
with self.assertRaises(exceptions.ValidationError) as cm:
ag_models.GroupInvitation.objects.validate_and_create(
invitation_creator=self.invitation_creator,
invited_users=other_invitees,
project=self.project)
self.assertIn('pending_invitation', cm.exception.message_dict)
def test_update_group_override_min_size(self):
group = ag_models.Group.objects.validate_and_create(
members=self.student_users,
project=self.project)
self.project.min_group_size = 10
self.project.max_group_size = 10
self.project.save()
new_members = obj_build.create_dummy_users(2)
self.project.course.students.add(*new_members)
group.validate_and_update(members=new_members,
check_group_size_limits=False)
group.refresh_from_db()
self.assertCountEqual(new_members, group.members.all())
def setUp(self):
super().setUp()
self.to_invite = obj_build.create_dummy_users(3)
self.to_invite_usernames = [user.username for user in self.to_invite]
self.invitation_creator = obj_build.create_dummy_user()
self.invitation_creator_username = self.invitation_creator.username
self.project = obj_build.build_project(
project_kwargs={
'min_group_size': 1,
'max_group_size': 4
},
course_kwargs={
'students':
list(itertools.chain([self.invitation_creator],
self.to_invite))
})
def setUp(self):
super().setUp()
self.current_students = obj_build.create_dummy_users(5)
self.course.students.add(*self.current_students)
def setUp(self):
super().setUp()
self.current_handgraders = obj_build.create_dummy_users(2)
self.course.handgraders.add(*self.current_handgraders)
