def test_can_not_invite_someone_that_is_already_in_projectgroup(self):
periodbuilder = PeriodBuilder.quickadd_ducku_duck1010_active() \
.add_relatedstudents(self.testuser2)
assignment1builder = periodbuilder.add_assignment(
'assignment1', students_can_create_groups=True)
assignment2builder = periodbuilder.add_assignment(
'assignment2', students_can_create_groups=True)
assignment1builder.add_group(students=[self.testuser2, self.testuser3])
group1 = assignment1builder.add_group(students=[self.testuser1]).group
group2 = assignment2builder.add_group(students=[self.testuser1]).group
with self.assertRaisesRegexp(
ValidationError,
r'^.*The invited student is already in a project group.*$'):
GroupInvite(group=group1,
sent_by=self.testuser1,
sent_to=self.testuser2,
accepted=True).clean()
# Ensure we are not affected by having groups in other assignments
GroupInvite(group=group2,
sent_by=self.testuser1,
sent_to=self.testuser2,
accepted=True).clean()
def test_send_accept_mail(self):
assignment = mommy.make(
'core.Assignment',
long_name='Assignment 1',
short_name='assignment1',
parentnode__long_name='Spring2017',
parentnode__short_name='s17',
parentnode__parentnode__long_name=
'DUCK1010 - Object Oriented Programming',
parentnode__parentnode__short_name='Duck1010',
students_can_create_groups=True,
)
testgroup = mommy.make('core.AssignmentGroup', parentnode=assignment)
testgroup1 = mommy.make('core.AssignmentGroup', parentnode=assignment)
sent_by = core_mommy.candidate(testgroup,
shortname="*****@*****.**",
fullname="April").relatedstudent.user
sent_to = core_mommy.candidate(testgroup1,
shortname="*****@*****.**",
fullname="Dewey").relatedstudent.user
mommy.make('devilry_account.UserEmail',
user=sent_to,
email="*****@*****.**")
mommy.make('devilry_account.UserEmail',
user=sent_by,
email="*****@*****.**")
invite = GroupInvite(group=testgroup, sent_by=sent_by, sent_to=sent_to)
invite.full_clean()
invite.save()
invite.send_invite_notification(self.__fake_request())
invite.respond(True)
self.assertEqual(len(mail.outbox), 2)
self.assertEqual(mail.outbox[1].subject,
'[Devilry] Dewey accepted your project group invite')
def test_validation_user_id_send_to_error_already_in_group(self):
assignment = mommy.make('core.Assignment', students_can_create_groups=True)
testgroup = mommy.make('core.AssignmentGroup', parentnode=assignment)
core_mommy.candidate(testgroup)
sent_to = core_mommy.candidate(testgroup)
with self.assertRaisesMessage(ValidationError, 'The selected student is not eligible to join the group.'):
GroupInvite.validate_candidate_id_sent_to(testgroup, sent_to.id)
def test_validate_user_id_send_to(self):
assignment = mommy.make('core.Assignment', students_can_create_groups=True)
testgroup = mommy.make('core.AssignmentGroup', parentnode=assignment)
testgroup1 = mommy.make('core.AssignmentGroup', parentnode=assignment)
core_mommy.candidate(testgroup)
sent_to = core_mommy.candidate(testgroup1)
with self.assertNumQueries(1):
GroupInvite.validate_candidate_id_sent_to(testgroup, sent_to.id)
def test_validate_user_id_send_to(self):
assignment = mommy.make('core.Assignment',
students_can_create_groups=True)
testgroup = mommy.make('core.AssignmentGroup', parentnode=assignment)
testgroup1 = mommy.make('core.AssignmentGroup', parentnode=assignment)
core_mommy.candidate(testgroup)
sent_to = core_mommy.candidate(testgroup1)
with self.assertNumQueries(1):
GroupInvite.validate_candidate_id_sent_to(testgroup, sent_to.id)
def clean(self):
cleaned_data = super(CreateForm, self).clean()
sent_to_userid = cleaned_data.get('sent_to')
if sent_to_userid:
sent_to = GroupInvite.send_invite_to_choices_queryset(self.group).get(id=sent_to_userid)
invite = GroupInvite(group=self.group, sent_by=self.sent_by, sent_to=sent_to)
invite.full_clean()
self.cleaned_invite = invite
return cleaned_data
def test_validation_user_id_send_to_error_already_in_group(self):
assignment = mommy.make('core.Assignment',
students_can_create_groups=True)
testgroup = mommy.make('core.AssignmentGroup', parentnode=assignment)
core_mommy.candidate(testgroup)
sent_to = core_mommy.candidate(testgroup)
with self.assertRaisesMessage(
ValidationError,
'The selected student is not eligible to join the group.'):
GroupInvite.validate_candidate_id_sent_to(testgroup, sent_to.id)
def test_send_accept_mail(self):
assignment = mommy.make(
'core.Assignment',
long_name='Assignment 1',
short_name='assignment1',
parentnode__long_name='Spring2017',
parentnode__short_name='s17',
parentnode__parentnode__long_name='DUCK1010 - Object Oriented Programming',
parentnode__parentnode__short_name='Duck1010',
students_can_create_groups=True,
)
testgroup = mommy.make('core.AssignmentGroup', parentnode=assignment)
testgroup1 = mommy.make('core.AssignmentGroup', parentnode=assignment)
sent_by = core_mommy.candidate(testgroup, shortname="*****@*****.**", fullname="April").relatedstudent.user
sent_to = core_mommy.candidate(testgroup1, shortname="*****@*****.**", fullname="Dewey").relatedstudent.user
mommy.make('devilry_account.UserEmail', user=sent_to, email="*****@*****.**")
mommy.make('devilry_account.UserEmail', user=sent_by, email="*****@*****.**")
invite = GroupInvite(
group=testgroup,
sent_by=sent_by,
sent_to=sent_to
)
invite.full_clean()
invite.save()
invite.send_invite_notification(self.__fake_request())
invite.respond(True)
self.assertEqual(len(mail.outbox), 2)
self.assertEqual(mail.outbox[1].subject, '[Devilry] Dewey accepted your project group invite')
def test_student_already_member_of_the_group(self):
testgroup = mommy.make('core.AssignmentGroup')
sent_by = core_mommy.candidate(testgroup).relatedstudent.user
sent_to = core_mommy.candidate(testgroup).relatedstudent.user
with self.assertRaisesMessage(
ValidationError,
'The student is already a member of the group.'):
invite = GroupInvite(group=testgroup,
sent_by=sent_by,
sent_to=sent_to)
invite.full_clean()
def test_invited_student_must_be_relatedstudent(self):
group = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_assignment('assignment1',
students_can_create_groups=True)\
.add_group(students=[self.testuser1]).group
invite = GroupInvite(
group=group,
sent_by=self.testuser1,
sent_to=self.testuser2)
with self.assertRaisesRegexp(ValidationError,
r'^.*The invited student is not registered on this subject.*$'):
invite.full_clean()
def test_only_when_allowed_on_assignment(self):
group = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_relatedstudents(self.testuser2)\
.add_assignment('assignment1',
students_can_create_groups=False)\
.add_group(students=[self.testuser1]).group
invite = GroupInvite(
group=group,
sent_by=self.testuser1,
sent_to=self.testuser2)
with self.assertRaisesRegexp(ValidationError,
r'^.*This assignment does not allow students to form project groups on their own.*$'):
invite.full_clean()
def test_invited_student_must_be_relatedstudent(self):
group = PeriodBuilder.quickadd_ducku_duck1010_active() \
.add_assignment('assignment1',
students_can_create_groups=True) \
.add_group(students=[self.testuser1]).group
invite = GroupInvite(group=group,
sent_by=self.testuser1,
sent_to=self.testuser2)
with self.assertRaisesRegexp(
ValidationError,
r'^.*The invited student is not registered on this subject.*$'
):
invite.full_clean()
def clean(self):
cleaned_data = super(CreateForm, self).clean()
sent_to_candidate_id = cleaned_data.get('sent_to')
if sent_to_candidate_id:
try:
sent_to = GroupInvite.validate_candidate_id_sent_to(self.group, sent_to_candidate_id)
except ValidationError as e:
self.cleaned_invite = None
else:
invite = GroupInvite(group=self.group, sent_by=self.sent_by, sent_to=sent_to)
invite.full_clean()
self.cleaned_invite = invite
return cleaned_data
def test_sanity(self):
testgroup = mommy.make('core.AssignmentGroup',
parentnode__students_can_create_groups=True)
testgroup1 = mommy.make('core.AssignmentGroup',
parentnode=testgroup.parentnode)
sent_by = core_mommy.candidate(testgroup).relatedstudent.user
sent_to = core_mommy.candidate(testgroup1).relatedstudent.user
invite = GroupInvite(group=testgroup, sent_by=sent_by, sent_to=sent_to)
invite.full_clean()
self.assertEqual(invite.sent_to, sent_to)
self.assertEqual(invite.sent_by, sent_by)
self.assertEqual(invite.group, testgroup)
self.assertIsNotNone(invite.sent_datetime)
def test_student_sent_to_is_not_registerd_on_assignment(self):
testgroup = mommy.make('core.AssignmentGroup',
parentnode__students_can_create_groups=True)
testgroup1 = mommy.make('core.AssignmentGroup')
sent_by = core_mommy.candidate(testgroup).relatedstudent.user
sent_to = core_mommy.candidate(testgroup1).relatedstudent.user
with self.assertRaisesMessage(
ValidationError,
'The invited student is not registered on this assignment.'):
invite = GroupInvite(group=testgroup,
sent_by=sent_by,
sent_to=sent_to)
invite.full_clean()
def test_students_can_not_create_groups_after(self):
group = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_relatedstudents(self.testuser2)\
.add_assignment('assignment1',
students_can_not_create_groups_after=DateTimeBuilder.now().minus(days=1),
students_can_create_groups=True)\
.add_group(students=[self.testuser1]).group
invite = GroupInvite(
group=group,
sent_by=self.testuser1,
sent_to=self.testuser2)
with self.assertRaisesRegexp(ValidationError,
r'^.*Creating project groups without administrator approval is not allowed on this assignment anymore.*$'):
invite.full_clean()
def test_only_when_allowed_on_assignment(self):
group = PeriodBuilder.quickadd_ducku_duck1010_active() \
.add_relatedstudents(self.testuser2) \
.add_assignment('assignment1',
students_can_create_groups=False) \
.add_group(students=[self.testuser1]).group
invite = GroupInvite(group=group,
sent_by=self.testuser1,
sent_to=self.testuser2)
with self.assertRaisesRegexp(
ValidationError,
r'^.*This assignment does not allow students to form '
r'project groups on their own.*$'):
invite.full_clean()
def test_student_already_member_of_the_group(self):
testgroup = mommy.make('core.AssignmentGroup')
sent_by = core_mommy.candidate(testgroup).relatedstudent.user
sent_to = core_mommy.candidate(testgroup).relatedstudent.user
with self.assertRaisesMessage(
ValidationError,
'The student is already a member of the group.'):
invite = GroupInvite(
group=testgroup,
sent_by=sent_by,
sent_to=sent_to
)
invite.full_clean()
def test_students_can_not_create_groups_after(self):
group = PeriodBuilder.quickadd_ducku_duck1010_active() \
.add_relatedstudents(self.testuser2) \
.add_assignment('assignment1',
students_can_not_create_groups_after=DateTimeBuilder.now().minus(days=1),
students_can_create_groups=True) \
.add_group(students=[self.testuser1]).group
invite = GroupInvite(group=group,
sent_by=self.testuser1,
sent_to=self.testuser2)
with self.assertRaisesRegexp(
ValidationError,
r'^.*Creating project groups without administrator approval is '
r'not allowed on this assignment anymore.*$'):
invite.full_clean()
def test_sanity(self):
testgroup = mommy.make('core.AssignmentGroup', parentnode__students_can_create_groups=True)
testgroup1 = mommy.make('core.AssignmentGroup', parentnode=testgroup.parentnode)
sent_by = core_mommy.candidate(testgroup).relatedstudent.user
sent_to = core_mommy.candidate(testgroup1).relatedstudent.user
invite = GroupInvite(
group=testgroup,
sent_by=sent_by,
sent_to=sent_to
)
invite.full_clean()
self.assertEqual(invite.sent_to, sent_to)
self.assertEqual(invite.sent_by, sent_by)
self.assertEqual(invite.group, testgroup)
self.assertIsNotNone(invite.sent_datetime)
def test_create_sanity(self):
group = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_relatedstudents(self.testuser2)\
.add_assignment('assignment1',
students_can_create_groups=True)\
.add_group(students=[self.testuser1]).group
before = datetime.now()
invite = GroupInvite(
group=group,
sent_by=self.testuser1,
sent_to=self.testuser2)
invite.full_clean()
invite.save()
after = datetime.now()
self.assertTrue(invite.sent_datetime >= before and invite.sent_datetime <= after)
def test_student_sent_to_is_not_registerd_on_assignment(self):
testgroup = mommy.make('core.AssignmentGroup', parentnode__students_can_create_groups=True)
testgroup1 = mommy.make('core.AssignmentGroup')
sent_by = core_mommy.candidate(testgroup).relatedstudent.user
sent_to = core_mommy.candidate(testgroup1).relatedstudent.user
with self.assertRaisesMessage(
ValidationError,
'The invited student is not registered on this assignment.'):
invite = GroupInvite(
group=testgroup,
sent_by=sent_by,
sent_to=sent_to
)
invite.full_clean()
def test_can_not_invite_someone_that_already_has_invite_for_group(self):
group = PeriodBuilder.quickadd_ducku_duck1010_active() \
.add_relatedstudents(self.testuser2) \
.add_assignment('assignment1',
students_can_create_groups=True) \
.add_group(students=[self.testuser1]).group
GroupInvite(group=group,
sent_by=self.testuser1,
sent_to=self.testuser2).save()
with self.assertRaisesRegexp(
ValidationError,
r'^.*The student is already invited to join the group, '
r'but they have not responded yet.*$'):
GroupInvite(group=group,
sent_by=self.testuser1,
sent_to=self.testuser2).clean()
def test_assignment_does_not_allow_students_to_form_groups(self):
testgroup = mommy.make('core.AssignmentGroup',
parentnode__students_can_create_groups=False)
testgroup1 = mommy.make('core.AssignmentGroup',
parentnode=testgroup.parentnode)
sent_by = core_mommy.candidate(testgroup).relatedstudent.user
sent_to = core_mommy.candidate(testgroup1).relatedstudent.user
with self.assertRaisesMessage(
ValidationError,
'This assignment does not allow students to form project groups on their own.'
):
invite = GroupInvite(group=testgroup,
sent_by=sent_by,
sent_to=sent_to)
invite.full_clean()
def _sent_to_choices(self):
candidates = GroupInvite.send_invite_to_choices_queryset(self.group)
choices = [
(candidate.id, candidate.relatedstudent.user.get_displayname())
for candidate in candidates]
choices.insert(0, ('', ''))
return choices
def test_user_sending_is_not_part_of_the_group(self):
testgroup = mommy.make('core.AssignmentGroup')
testgroup1 = mommy.make('core.AssignmentGroup', parentnode=testgroup.parentnode)
testgroup2 = mommy.make('core.AssignmentGroup', parentnode=testgroup.parentnode)
sent_by = core_mommy.candidate(testgroup1).relatedstudent.user
sent_to = core_mommy.candidate(testgroup2).relatedstudent.user
with self.assertRaisesMessage(
ValidationError,
'The user sending an invite must be a Candiate on the group.'):
invite = GroupInvite(
group=testgroup,
sent_by=sent_by,
sent_to=sent_to
)
invite.full_clean()
def test_student_already_invited_but_not_responded(self):
testgroup = mommy.make('core.AssignmentGroup', parentnode__students_can_create_groups=True)
testgroup1 = mommy.make('core.AssignmentGroup', parentnode=testgroup.parentnode)
sent_by = core_mommy.candidate(testgroup).relatedstudent.user
sent_to = core_mommy.candidate(testgroup1).relatedstudent.user
mommy.make('core.GroupInvite', group=testgroup, sent_by=sent_by, sent_to=sent_to)
with self.assertRaisesMessage(
ValidationError,
'The student is already invited to join the group, but they have not responded yet.'):
invite = GroupInvite(
group=testgroup,
sent_by=sent_by,
sent_to=sent_to
)
invite.full_clean()
def test_send_invite_to_choices_queryset_pending_is_excluded(self):
group1 = mommy.make('core.AssignmentGroup',
parentnode__students_can_create_groups=True)
group2 = mommy.make('core.AssignmentGroup',
parentnode=group1.parentnode)
group3 = mommy.make('core.AssignmentGroup',
parentnode=group1.parentnode)
group4 = mommy.make('core.AssignmentGroup',
parentnode=group1.parentnode)
candidate1 = core_mommy.candidate(group=group1,
fullname="Louie",
shortname="louie")
core_mommy.candidate(group=group2, fullname="Huey", shortname="huey")
core_mommy.candidate(group=group2,
fullname="Donald",
shortname="donald")
candidate4 = core_mommy.candidate(group=group3,
fullname="April",
shortname="april")
candidate5 = core_mommy.candidate(group=group4,
fullname="Dewey",
shortname="dewey")
mommy.make('core.GroupInvite',
group=group1,
sent_to=candidate4.relatedstudent.user,
sent_by=candidate1.relatedstudent.user)
candidates = GroupInvite.send_invite_to_choices_queryset(group1)
self.assertEqual(candidates.count(), 1)
self.assertEqual(set(candidate.id for candidate in candidates),
{candidate5.id})
def test_user_sending_is_not_part_of_the_group(self):
testgroup = mommy.make('core.AssignmentGroup')
testgroup1 = mommy.make('core.AssignmentGroup',
parentnode=testgroup.parentnode)
testgroup2 = mommy.make('core.AssignmentGroup',
parentnode=testgroup.parentnode)
sent_by = core_mommy.candidate(testgroup1).relatedstudent.user
sent_to = core_mommy.candidate(testgroup2).relatedstudent.user
with self.assertRaisesMessage(
ValidationError,
'The user sending an invite must be a Candiate on the group.'):
invite = GroupInvite(group=testgroup,
sent_by=sent_by,
sent_to=sent_to)
invite.full_clean()
def test_assignment_does_not_allow_students_to_form_groups(self):
testgroup = mommy.make('core.AssignmentGroup',
parentnode__students_can_create_groups=False)
testgroup1 = mommy.make('core.AssignmentGroup', parentnode=testgroup.parentnode)
sent_by = core_mommy.candidate(testgroup).relatedstudent.user
sent_to = core_mommy.candidate(testgroup1).relatedstudent.user
with self.assertRaisesMessage(
ValidationError,
'This assignment does not allow students to form project groups on their own.'):
invite = GroupInvite(
group=testgroup,
sent_by=sent_by,
sent_to=sent_to
)
invite.full_clean()
def test_respond_accept_add_candidate(self):
group = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_relatedstudents(self.testuser2)\
.add_assignment('assignment1', students_can_create_groups=True)\
.add_group(students=[self.testuser1]).group
invite = GroupInvite(
group=group,
sent_by=self.testuser1,
sent_to=self.testuser2)
invite.save()
self.assertEquals(AssignmentGroup.objects.count(), 1)
invite.respond(accepted=True)
self.assertTrue(invite.accepted)
self.assertTrue(group.candidates.count(), 2)
self.assertEquals(set([c.student for c in group.candidates.all()]),
set([self.testuser1, self.testuser2]))
self.assertEquals(AssignmentGroup.objects.count(), 1)
def test_student_sent_to_is_already_in_a_group_with_more_than_one_student(self):
testgroup = mommy.make('core.AssignmentGroup', parentnode__students_can_create_groups=True)
testgroup1 = mommy.make('core.AssignmentGroup', parentnode=testgroup.parentnode)
sent_by = core_mommy.candidate(testgroup).relatedstudent.user
sent_to = core_mommy.candidate(testgroup1).relatedstudent.user
core_mommy.candidate(testgroup1)
with self.assertRaisesMessage(
ValidationError,
'The invited student is already in a project group with more than 1 students.'):
invite = GroupInvite(
group=testgroup,
sent_by=sent_by,
sent_to=sent_to,
accepted=True
)
invite.full_clean()
def test_send_invite_mail(self):
assignment = mommy.make(
'core.Assignment',
long_name='Assignment 1',
short_name='assignment1',
parentnode__long_name='Spring2017',
parentnode__short_name='s17',
parentnode__parentnode__long_name='DUCK1010 - Object Oriented Programming',
parentnode__parentnode__short_name='Duck1010',
students_can_create_groups=True,
)
testgroup = mommy.make('core.AssignmentGroup', parentnode=assignment)
testgroup1 = mommy.make('core.AssignmentGroup', parentnode=assignment)
sent_by = core_mommy.candidate(testgroup, shortname="*****@*****.**", fullname="April").relatedstudent.user
sent_to = core_mommy.candidate(testgroup1, shortname="*****@*****.**", fullname="Dewey").relatedstudent.user
mommy.make('devilry_account.UserEmail', user=sent_to, email="*****@*****.**")
invite = GroupInvite(group=testgroup, sent_by=sent_by, sent_to=sent_to)
invite.full_clean()
invite.save()
request = self.__fake_request()
invite.send_invite_notification(request)
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].subject, '[Devilry] Project group invite for Duck1010.s17.assignment1')
url = request.build_absolute_uri(
reverse('devilry_student_groupinvite_respond', kwargs={'invite_id': invite.id}))
self.assertIn(url, mail.outbox[0].body)
def test_respond_reject(self):
group = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_relatedstudents(self.testuser2)\
.add_assignment('assignment1', students_can_create_groups=True)\
.add_group(students=[self.testuser1]).group
invite = GroupInvite(
group=group,
sent_by=self.testuser1,
sent_to=self.testuser2)
invite.save()
self.assertIsNone(invite.accepted)
before = datetime.now()
invite.respond(accepted=False)
after = datetime.now()
self.assertFalse(invite.accepted)
self.assertTrue(invite.responded_datetime >= before and invite.responded_datetime <= after)
self.assertTrue(group.candidates.count(), 1)
def test_create_groups_expired(self):
testgroup = mommy.make('core.AssignmentGroup',
parentnode__students_can_create_groups=True,
parentnode__students_can_not_create_groups_after=timezone.now() - timedelta(days=1))
testgroup1 = mommy.make('core.AssignmentGroup', parentnode=testgroup.parentnode)
sent_by = core_mommy.candidate(testgroup).relatedstudent.user
sent_to = core_mommy.candidate(testgroup1).relatedstudent.user
with self.assertRaisesMessage(
ValidationError,
'Creating project groups without administrator approval is not '
'allowed on this assignment anymore. Please contact you course '
'administrator if you think this is wrong.'):
invite = GroupInvite(
group=testgroup,
sent_by=sent_by,
sent_to=sent_to
)
invite.full_clean()
def test_student_sent_to_is_already_in_a_group_with_more_than_one_student(
self):
testgroup = mommy.make('core.AssignmentGroup',
parentnode__students_can_create_groups=True)
testgroup1 = mommy.make('core.AssignmentGroup',
parentnode=testgroup.parentnode)
sent_by = core_mommy.candidate(testgroup).relatedstudent.user
sent_to = core_mommy.candidate(testgroup1).relatedstudent.user
core_mommy.candidate(testgroup1)
with self.assertRaisesMessage(
ValidationError,
'The invited student is already in a project group with more than 1 students.'
):
invite = GroupInvite(group=testgroup,
sent_by=sent_by,
sent_to=sent_to,
accepted=True)
invite.full_clean()
def test_create_groups_expired(self):
testgroup = mommy.make(
'core.AssignmentGroup',
parentnode__students_can_create_groups=True,
parentnode__students_can_not_create_groups_after=timezone.now() -
timedelta(days=1))
testgroup1 = mommy.make('core.AssignmentGroup',
parentnode=testgroup.parentnode)
sent_by = core_mommy.candidate(testgroup).relatedstudent.user
sent_to = core_mommy.candidate(testgroup1).relatedstudent.user
with self.assertRaisesMessage(
ValidationError,
'Creating project groups without administrator approval is not '
'allowed on this assignment anymore. Please contact you course '
'administrator if you think this is wrong.'):
invite = GroupInvite(group=testgroup,
sent_by=sent_by,
sent_to=sent_to)
invite.full_clean()
def test_student_already_invited_but_not_responded(self):
testgroup = mommy.make('core.AssignmentGroup',
parentnode__students_can_create_groups=True)
testgroup1 = mommy.make('core.AssignmentGroup',
parentnode=testgroup.parentnode)
sent_by = core_mommy.candidate(testgroup).relatedstudent.user
sent_to = core_mommy.candidate(testgroup1).relatedstudent.user
mommy.make('core.GroupInvite',
group=testgroup,
sent_by=sent_by,
sent_to=sent_to)
with self.assertRaisesMessage(
ValidationError,
'The student is already invited to join the group, but they have not responded yet.'
):
invite = GroupInvite(group=testgroup,
sent_by=sent_by,
sent_to=sent_to)
invite.full_clean()
def test_can_not_invite_self(self):
group = PeriodBuilder.quickadd_ducku_duck1010_active() \
.add_relatedstudents(self.testuser1) \
.add_assignment('assignment1',
students_can_create_groups=True) \
.add_group(students=[self.testuser1]).group
with self.assertRaisesRegexp(
ValidationError,
r'^.*The student is already a member of the group.*$'):
GroupInvite(group=group,
sent_by=self.testuser1,
sent_to=self.testuser1).clean()
def test_only_groupmember_can_invite(self):
group = PeriodBuilder.quickadd_ducku_duck1010_active() \
.add_relatedstudents(self.testuser2) \
.add_assignment('assignment1',
students_can_create_groups=True) \
.add_group(students=[self.testuser1]).group
with self.assertRaisesRegexp(
ValidationError,
r'^.*The user sending an invite must be a Candiate on the group.*$'
):
GroupInvite(group=group,
sent_by=self.testuser2,
sent_to=self.testuser3).clean()
def test_send_invite_to_choices_queryset(self):
group1 = mommy.make('core.AssignmentGroup', parentnode__students_can_create_groups=True)
group2 = mommy.make('core.AssignmentGroup', parentnode=group1.parentnode)
group3 = mommy.make('core.AssignmentGroup', parentnode=group1.parentnode)
group4 = mommy.make('core.AssignmentGroup', parentnode=group1.parentnode)
core_mommy.candidate(group=group1, fullname="Louie", shortname="louie")
core_mommy.candidate(group=group2, fullname="Huey", shortname="huey")
core_mommy.candidate(group=group2, fullname="Donald", shortname="donald")
candidate4 = core_mommy.candidate(group=group3, fullname="April", shortname="april")
candidate5 = core_mommy.candidate(group=group4, fullname="Dewey", shortname="dewey")
candidates = GroupInvite.send_invite_to_choices_queryset(group1)
self.assertEqual(candidates.count(), 2)
self.assertEqual(
set(candidate.id for candidate in candidates),
{candidate4.id, candidate5.id}
)
def test_send_invite_to_choices_queryset(self):
UserBuilder('ignoreduser')
alreadyingroupuser1 = UserBuilder('alreadyingroupuser1').user
alreadyingroupuser2 = UserBuilder('alreadyingroupuser2').user
hasinviteuser = UserBuilder('hasinviteuser').user
matchuser1 = UserBuilder('matchuser1').user
matchuser2 = UserBuilder('matchuser2').user
group = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_relatedstudents(
alreadyingroupuser1, alreadyingroupuser2, hasinviteuser,
matchuser1, matchuser2)\
.add_assignment('assignment1', students_can_create_groups=True)\
.add_group(students=[alreadyingroupuser1, alreadyingroupuser2]).group
group.groupinvite_set.create(
sent_by=alreadyingroupuser1,
sent_to=hasinviteuser)
can_invite_users = set(GroupInvite.send_invite_to_choices_queryset(group))
self.assertEquals(can_invite_users, set([matchuser1, matchuser2]))
def test_send_invite_to_choices_queryset(self):
UserBuilder('ignoreduser')
alreadyingroupuser1 = UserBuilder('alreadyingroupuser1').user
alreadyingroupuser2 = UserBuilder('alreadyingroupuser2').user
hasinviteuser = UserBuilder('hasinviteuser').user
matchuser1 = UserBuilder('matchuser1').user
matchuser2 = UserBuilder('matchuser2').user
group = PeriodBuilder.quickadd_ducku_duck1010_active() \
.add_relatedstudents(
alreadyingroupuser1, alreadyingroupuser2, hasinviteuser,
matchuser1, matchuser2) \
.add_assignment('assignment1', students_can_create_groups=True) \
.add_group(students=[alreadyingroupuser1, alreadyingroupuser2]).group
group.groupinvite_set.create(sent_by=alreadyingroupuser1,
sent_to=hasinviteuser)
can_invite_users = set(
GroupInvite.send_invite_to_choices_queryset(group))
self.assertEquals(can_invite_users, set([matchuser1, matchuser2]))
def test_create_sanity(self):
group = PeriodBuilder.quickadd_ducku_duck1010_active() \
.add_relatedstudents(self.testuser2) \
.add_assignment('assignment1',
students_can_create_groups=True) \
.add_group(students=[self.testuser1]).group
before = datetime.now()
invite = GroupInvite(group=group,
sent_by=self.testuser1,
sent_to=self.testuser2)
invite.full_clean()
invite.save()
after = datetime.now()
self.assertTrue(invite.sent_datetime >= before
and invite.sent_datetime <= after)
def test_respond_accept_add_candidate(self):
group = PeriodBuilder.quickadd_ducku_duck1010_active() \
.add_relatedstudents(self.testuser2) \
.add_assignment('assignment1', students_can_create_groups=True) \
.add_group(students=[self.testuser1]).group
invite = GroupInvite(group=group,
sent_by=self.testuser1,
sent_to=self.testuser2)
invite.save()
self.assertEquals(AssignmentGroup.objects.count(), 1)
invite.respond(accepted=True)
self.assertTrue(invite.accepted)
self.assertTrue(group.candidates.count(), 2)
self.assertEquals(set([c.student for c in group.candidates.all()]),
set([self.testuser1, self.testuser2]))
self.assertEquals(AssignmentGroup.objects.count(), 1)
def test_send_invite_mail(self):
assignment = mommy.make(
'core.Assignment',
long_name='Assignment 1',
short_name='assignment1',
parentnode__long_name='Spring2017',
parentnode__short_name='s17',
parentnode__parentnode__long_name=
'DUCK1010 - Object Oriented Programming',
parentnode__parentnode__short_name='Duck1010',
students_can_create_groups=True,
)
testgroup = mommy.make('core.AssignmentGroup', parentnode=assignment)
testgroup1 = mommy.make('core.AssignmentGroup', parentnode=assignment)
sent_by = core_mommy.candidate(testgroup,
shortname="*****@*****.**",
fullname="April").relatedstudent.user
sent_to = core_mommy.candidate(testgroup1,
shortname="*****@*****.**",
fullname="Dewey").relatedstudent.user
mommy.make('devilry_account.UserEmail',
user=sent_to,
email="*****@*****.**")
invite = GroupInvite(group=testgroup, sent_by=sent_by, sent_to=sent_to)
invite.full_clean()
invite.save()
request = self.__fake_request()
invite.send_invite_notification(request)
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(
mail.outbox[0].subject,
'[Devilry] Project group invite for Duck1010.s17.assignment1')
url = request.build_absolute_uri(
reverse('devilry_student_groupinvite_respond',
kwargs={'invite_id': invite.id}))
self.assertIn(url, mail.outbox[0].body)
def test_respond_reject(self):
group = PeriodBuilder.quickadd_ducku_duck1010_active() \
.add_relatedstudents(self.testuser2) \
.add_assignment('assignment1', students_can_create_groups=True) \
.add_group(students=[self.testuser1]).group
invite = GroupInvite(group=group,
sent_by=self.testuser1,
sent_to=self.testuser2)
invite.save()
self.assertIsNone(invite.accepted)
before = datetime.now()
invite.respond(accepted=False)
after = datetime.now()
self.assertFalse(invite.accepted)
self.assertTrue(invite.responded_datetime >= before
and invite.responded_datetime <= after)
self.assertTrue(group.candidates.count(), 1)
def _sent_to_choices(self):
users = GroupInvite.send_invite_to_choices_queryset(self.group)
choices = [(user.id, user.get_full_name()) for user in users]
choices.insert(0, ('', ''))
return choices
def _sent_to_choices(self):
users = GroupInvite.send_invite_to_choices_queryset(self.group)
choices = [(user.id, user.devilryuserprofile.get_displayname()) for user in users]
choices.insert(0, ('', ''))
return choices
