def test_create_group_and_invitation_with_member_in_both(self):
self.visible_public_project.validate_and_update(max_group_size=4)
project_id = self.visible_public_project.pk
invitor = obj_build.create_dummy_user()
overlap_username = '******'
path = 'autograder.rest_api.views.group_views.GroupsViewSet.serializer_class'
@test_ut.sleeper_subtest(path, wraps=GroupsViewSet.serializer_class)
def do_request_and_wait(project_id):
project = ag_models.Project.objects.get(pk=project_id)
client = APIClient()
client.force_authenticate(self.admin)
response = client.post(
self.get_groups_url(project),
{'member_names': [overlap_username, 'this_one']})
self.assertEqual(status.HTTP_201_CREATED, response.status_code)
self.assertEqual(1, ag_models.Group.objects.count())
subtest = do_request_and_wait(project_id)
self.client.force_authenticate(invitor)
response = self.client.post(
self.get_invitations_url(self.visible_public_project),
{'invited_usernames': [overlap_username]})
subtest.join()
self.assertEqual(status.HTTP_400_BAD_REQUEST, response.status_code)
self.assertEqual(1, ag_models.Group.objects.count())
def test_registration_disabled_permission_denied_for_non_enrolled(self):
self.visible_public_project.validate_and_update(
max_group_size=3, disallow_group_registration=True)
data = {'invited_usernames': [obj_build.create_dummy_user().username]}
self.do_permission_denied_create_test(
ag_models.GroupInvitation.objects, self.client, self.nobody,
self.get_invitations_url(self.visible_public_project), data)
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 test_other_create_invitation(self):
self.visible_public_project.validate_and_update(max_group_size=3)
other_nobody = obj_build.create_dummy_user()
args = {'invited_usernames': [other_nobody.username, 'steve']}
self.do_create_object_test(
self.visible_public_project.group_invitations,
self.client, self.nobody,
self.get_invitations_url(self.visible_public_project), args)
def test_exception_on_too_many_invitees(self):
self.to_invite.append(obj_build.create_dummy_user())
with self.assertRaises(exceptions.ValidationError) as cm:
ag_models.GroupInvitation.objects.validate_and_create(
invited_users=self.to_invite,
invitation_creator=self.invitation_creator,
project=self.project)
self.assertTrue('invited_users' in cm.exception.message_dict)
def test_exception_on_too_many_group_members(self):
self.project.save()
new_user = obj_build.create_dummy_user()
self.course.students.add(new_user)
self.student_users.append(new_user)
with self.assertRaises(exceptions.ValidationError):
ag_models.Group.objects.validate_and_create(
members=self.student_users, project=self.project)
def test_nobody_create_invitation_private_or_hidden_project_permission_denied(
self):
other_nobody = obj_build.create_dummy_user()
args = {'invited_usernames': [other_nobody.username]}
for project in (self.visible_private_project,
self.hidden_public_project,
self.hidden_private_project):
self.do_permission_denied_create_test(
project.group_invitations, self.client, self.nobody,
self.get_invitations_url(project), args)
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_other_add_staff_permission_denied(self):
current_staff = obj_build.create_dummy_user()
self.course.staff.add(current_staff)
for user in current_staff, self.student, self.guest, self.handgrader:
self.client.force_authenticate(user)
response = self.client.post(self.url,
{'new_staff': ['spam', 'steve']})
self.assertEqual(403, response.status_code)
self.assertCountEqual([current_staff], self.course.staff.all())
def test_exception_on_some_members_not_enrolled(self):
mixed_group = self.student_users[0:1] + [obj_build.create_dummy_user()]
with self.assertRaises(exceptions.ValidationError):
ag_models.Group.objects.validate_and_create(
members=mixed_group, project=self.project)
self.project.guests_can_submit = True
self.project.save()
with self.assertRaises(exceptions.ValidationError):
ag_models.Group.objects.validate_and_create(
members=mixed_group, project=self.project)
def test_self_list_groups_is_member_of(self):
for group in self.all_groups(self.visible_public_project):
self.do_list_objects_test(
self.client, group.members.first(),
user_url(group.members.first(), 'user-groups-is-member-of'),
ag_serializers.SubmissionGroupSerializer([group],
many=True).data)
other_user = obj_build.create_dummy_user()
self.do_list_objects_test(
self.client, other_user,
user_url(other_user, 'user-groups-is-member-of'),
ag_serializers.SubmissionGroupSerializer([], many=True).data)
def test_serializable_fields(self):
expected_fields = [
'pk',
'timestamp',
'message',
'recipient',
]
self.assertCountEqual(expected_fields,
ag_models.Notification.get_serializable_fields())
notification = ag_models.Notification.objects.validate_and_create(
message='waaaaaaaaaluigi', recipient=obj_build.create_dummy_user())
self.assertTrue(notification.to_dict())
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_self_list_invitations_sent(self):
invite = self.non_enrolled_group_invitation(
self.visible_public_project)
self.do_list_objects_test(
self.client, invite.invitation_creator,
user_url(invite.invitation_creator, 'user-group-invitations-sent'),
ag_serializers.SubmissionGroupInvitationSerializer([invite],
many=True).data)
other_user = obj_build.create_dummy_user()
self.do_list_objects_test(
self.client, other_user,
user_url(other_user, 'user-group-invitations-sent'),
ag_serializers.SubmissionGroupInvitationSerializer([],
many=True).data)
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 admin(self):
if not hasattr(self, '_admin'):
self._admin = obj_build.create_dummy_user()
self.course.admins.add(self._admin)
return self._admin
def setUp(self):
super().setUp()
self.course = obj_build.make_course()
self.user = obj_build.create_dummy_user()
def setUp(self):
super().setUp()
self.user = obj_build.create_dummy_user()
def test_serialize(self):
notification = ag_models.Notification.objects.validate_and_create(
message='spamspamspam', recipient=obj_build.create_dummy_user())
self.do_basic_serialize_test(notification,
ag_serializers.NotificationSerializer)
def enrolled(self):
if not hasattr(self, '_enrolled'):
self._enrolled = obj_build.create_dummy_user()
self.course.students.add(self._enrolled)
return self._enrolled
def handgrader(self):
if not hasattr(self, '_handgrader'):
self._handgrader = obj_build.create_dummy_user()
self.course.handgraders.add(self._handgrader)
return self._handgrader
def staff(self):
if not hasattr(self, '_staff'):
self._staff = obj_build.create_dummy_user()
self.course.staff.add(self._staff)
return self._staff
def superuser(self):
if not hasattr(self, '_superuser'):
self._superuser = obj_build.create_dummy_user(is_superuser=True)
return self._superuser
def nobody(self):
if not hasattr(self, '_nobody'):
self._nobody = obj_build.create_dummy_user()
return self._nobody
