def test_smart_create_non_electronic(self):
assignment = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_assignment('assignment1', delivery_types=deliverytypes.NON_ELECTRONIC).assignment
group1 = AssignmentGroup(parentnode=assignment)
group2 = AssignmentGroup(parentnode=assignment)
for group in group1, group2:
group.save(autocreate_first_deadline_for_nonelectronic=False)
deadline_datetime = Deadline.reduce_datetime_precision(DateTimeBuilder.now().plus(days=10))
result = Deadline.objects.smart_create(
assignment.assignmentgroups.all(),
deadline_datetime=deadline_datetime,
text='Hello world')
self.assertIsNone(result)
self.assertEquals(group1.deadlines.count(), 1)
group1 = AssignmentGroup.objects.get(id=group1.id) # Reload from db
created_deadline = group1.deadlines.all()[0]
self.assertEquals(created_deadline.deadline, deadline_datetime)
self.assertEquals(created_deadline.text, 'Hello world')
self.assertEquals(group1.last_deadline, created_deadline)
self.assertEquals(group1.last_deadline.deliveries.count(), 1)
self.assertEquals(group1.last_deadline.deliveries.all()[0], group1.last_delivery)
self.assertTrue(group1.last_delivery.successful)
self.assertEquals(group1.last_delivery.number, 1)
group2 = AssignmentGroup.objects.get(id=group2.id) # Reload from db
self.assertEquals(group2.deadlines.all()[0].deadline, deadline_datetime)
self.assertEquals(group2.last_deadline, group2.deadlines.all()[0])
self.assertEquals(group2.last_deadline.deliveries.count(), 1)
self.assertEquals(group2.last_deadline.deliveries.all()[0], group2.last_delivery)
self.assertTrue(group2.last_delivery.successful)
self.assertEquals(group2.last_delivery.number, 1)
def test_invite_email(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 = group.groupinvite_set.create(
sent_by=self.testuser1,
sent_to=self.testuser2)
self.assertEqual(len(mail.outbox), 0)
class FakeRequest(object):
def build_absolute_uri(self, location):
return 'http://example.com{}'.format(location)
invite.send_invite_notification(FakeRequest())
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].to, ['*****@*****.**'])
self.assertEqual(mail.outbox[0].subject, '[Devilry] Project group invite for duck1010.active.assignment1')
self.assertIn(
u'testuser1 invited you to join their project\ngroup for duck1010 assignment1.',
mail.outbox[0].body)
self.assertIn(
'http://example.com{}'.format(reverse('devilry_student_groupinvite_respond',
kwargs={'invite_id': invite.id})),
mail.outbox[0].body)
def test_update(self):
periodbuilder = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_admins(self.testuser)
publishing_time = DateTimeBuilder.now().plus(days=10)
assignment1builder = periodbuilder.add_assignment('assignment1',
long_name='Assignment One',
anonymous=True,
publishing_time=publishing_time,
deadline_handling=1,
max_points=10, # Should not be touched by the update
passing_grade_min_points=8 # Should not be touched by the update
)
new_publishing_time = DateTimeBuilder.now().plus(days=20).replace(second=0, microsecond=0, tzinfo=None)
response = self._postas(assignment1builder.assignment.id, self.testuser, {
'long_name': 'Test One',
'short_name': 'test1',
'anonymous': '',
'publishing_time': isoformat_datetime(new_publishing_time),
'deadline_handling': 0
})
self.assertEquals(response.status_code, 302)
assignment1builder.reload_from_db()
assignment = assignment1builder.assignment
self.assertEquals(assignment.long_name, 'Test One')
self.assertEquals(assignment.short_name, 'test1')
self.assertFalse(assignment.anonymous)
self.assertEquals(assignment.publishing_time, new_publishing_time)
self.assertEquals(assignment.deadline_handling, 0)
self.assertEquals(assignment.max_points, 10)
self.assertEquals(assignment.passing_grade_min_points, 8)
def setUp(self):
self.admin1 = UserBuilder("admin1").user
self.assignmentbuilder = (
PeriodBuilder.quickadd_ducku_duck1010_active().add_assignment("assignment1").add_admins(self.admin1)
)
self.url = reverse(
"devilry_gradingsystem_admin_setmaxpoints", kwargs={"assignmentid": self.assignmentbuilder.assignment.id}
)
def test_set_last_deadline_on_group_single(self):
groupbuilder = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_assignment('assignment1')\
.add_group()
self.assertIsNone(groupbuilder.group.last_deadline)
deadline = groupbuilder.group.deadlines.create(deadline=DateTimeBuilder.now().plus(days=3))
groupbuilder.reload_from_db()
self.assertEquals(groupbuilder.group.last_deadline, deadline)
def test_render(self):
group = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_assignment('assignment1')\
.add_group(students=[self.testuser]).group
response = self._getas(group.id, self.testuser)
self.assertEquals(response.status_code, 200)
html = response.content
self.assertEquals(cssGet(html, 'h1').text.strip(), 'Project group')
def test_create_deadline_changes_assignmentgroup_delivery_status(self):
groupbuilder = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_assignment('assignment1')\
.add_group()
self.assertEquals(groupbuilder.group.delivery_status, 'no-deadlines')
groupbuilder.group.deadlines.create(deadline=DateTimeBuilder.now().plus(days=3))
groupbuilder.reload_from_db()
self.assertEquals(groupbuilder.group.delivery_status, 'waiting-for-something')
def test_create_deadline_opens_assignmentgroup(self):
groupbuilder = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_assignment('assignment1')\
.add_group()
groupbuilder.update(is_open=False)
groupbuilder.group.deadlines.create(deadline=DateTimeBuilder.now().plus(days=3))
groupbuilder.reload_from_db()
self.assertTrue(groupbuilder.group.is_open)
def test_filter_admin_has_access_directly_on_assignment(self):
admin1 = UserBuilder('admin1').user
periodbuilder = PeriodBuilder.quickadd_ducku_duck1010_active()
assignment1 = periodbuilder.add_assignment('assignment1').add_admins(admin1).assignment
periodbuilder.add_assignment('assignment2')
qry = Assignment.objects.filter_admin_has_access(admin1)
self.assertEquals(qry.count(), 1)
self.assertEquals(qry[0], assignment1)
def test_points_to_grade_points(self):
assignment1 = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_assignment('assignment1',
points_to_grade_mapper='raw-points',
max_points=10).assignment
self.assertEquals(assignment1.points_to_grade(0), '0/10')
self.assertEquals(assignment1.points_to_grade(1), '1/10')
self.assertEquals(assignment1.points_to_grade(10), '10/10')
def setUp(self):
self.admin1 = UserBuilder('admin1').user
self.assignmentbuilder = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_assignment('assignment1')\
.add_admins(self.admin1)
self.url = reverse('devilry_gradingsystem_admin_selectplugin', kwargs={
'assignmentid': self.assignmentbuilder.assignment.id,
})
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_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_autocreate_delivery_if_nonelectronic_false(self):
groupbuilder = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_assignment('assignment1',
delivery_types=deliverytypes.NON_ELECTRONIC)\
.add_group()
deadline = Deadline(
assignment_group=groupbuilder.group,
deadline=DateTimeBuilder.now().plus(days=10))
deadline.save(autocreate_delivery_if_nonelectronic=False)
self.assertEquals(deadline.deliveries.count(), 0)
def test_render_current_group_members(self):
otheruser = UserBuilder('otheruser').user
group = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_assignment('assignment1', students_can_create_groups=True)\
.add_group(students=[self.testuser, otheruser]).group
html = self._getas(group.id, self.testuser).content
names = [element.text.strip() for element in \
cssFind(html, '#devilry_student_groupinvite_overview_already_in_group .groupmember_username')]
self.assertEquals(set(names), set(['testuser', 'otheruser']))
def test_only_if_invited(self):
notalloweduser = UserBuilder('notalloweduser').user
group = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_assignment('assignment1')\
.add_group(students=[self.testfromuser]).group
invite = group.groupinvite_set.create(
sent_by=self.testfromuser,
sent_to=self.testtouser)
response = self._getas(invite.id, notalloweduser)
self.assertEquals(response.status_code, 404)
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, but they have not responded yet.*$'):
GroupInvite(group=group, sent_by=self.testuser1, sent_to=self.testuser2).clean()
def test_autocreate_delivery_if_nonelectronic(self):
groupbuilder = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_assignment('assignment1',
delivery_types=deliverytypes.NON_ELECTRONIC)\
.add_group()
deadline = groupbuilder.group.deadlines.create(deadline=DateTimeBuilder.now().plus(days=10))
self.assertEquals(deadline.deliveries.count(), 1)
self.assertTrue(deadline.deliveries.all()[0].successful)
groupbuilder.reload_from_db()
self.assertEquals(groupbuilder.group.last_delivery, deadline.deliveries.all()[0])
def test_list_single(self):
currentperiodbuilder = PeriodBuilder.quickadd_ducku_duck1010_active()
week1builder = currentperiodbuilder.add_assignment('week1', 'Week 1')
week1builder.add_group().add_examiners(self.examiner1)
response = self._getas('examiner1')
self.assertEquals(response.status_code, 200)
html = response.content
self.assertEquals(len(cssFind(html, '.active-assignment-listing-item')), 1)
linktag = cssGet(html, 'a.assignment-duck1010.active.week1')
self.assertEquals(linktag.text.strip(), 'duck1010.active - Week 1')
self.assertEquals(linktag['href'], '/devilry_examiner/allgroupsoverview/{}/waiting_for_feedback_or_all'.format(week1builder.assignment.id))
def test_filter_is_examiner(self):
examiner1 = UserBuilder('examiner1').user
week1builder = PeriodBuilder.quickadd_ducku_duck1010_active().add_assignment('week1')
group1builder = week1builder.add_group().add_examiners(examiner1)
# Add another group to make sure we do not get false positives
week1builder.add_group().add_examiners(UserBuilder('examiner2').user)
qry = Assignment.objects.filter_is_examiner(examiner1)
self.assertEquals(qry.count(), 1)
self.assertEquals(qry[0], week1builder.assignment)
def test_post_ok(self):
notalloweduser = UserBuilder('notalloweduser').user
group = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_assignment('assignment1')\
.add_group(students=[self.testfromuser, notalloweduser]).group
invite = group.groupinvite_set.create(
sent_by=self.testfromuser,
sent_to=self.testtouser)
response = self._postas(invite.id, self.testfromuser)
self.assertEquals(response.status_code, 302)
self.assertFalse(GroupInvite.objects.filter(id=invite.id).exists())
def test_set_last_deadline_on_group_merge(self):
assignmentbuilder = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_assignment('assignment1')
group1builder = assignmentbuilder.add_group()
group2builder = assignmentbuilder.add_group()
deadline2 = group2builder.group.deadlines.create(deadline=DateTimeBuilder.now().plus(days=10))
deadline3 = group1builder.group.deadlines.create(deadline=DateTimeBuilder.now().plus(days=15))
deadline1 = group1builder.group.deadlines.create(deadline=DateTimeBuilder.now().plus(days=5))
group2builder.group.merge_into(group1builder.group)
group1builder.reload_from_db()
self.assertEquals(group1builder.group.last_deadline, deadline3)
def setUp(self):
self.examiner1 = UserBuilder('examiner1').user
self.deliverybuilder = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_assignment('assignment1',
points_to_grade_mapper='raw-points',
passing_grade_min_points=20,
max_points=100
)\
.add_group(examiners=[self.examiner1])\
.add_deadline_in_x_weeks(weeks=1)\
.add_delivery_x_hours_before_deadline(hours=1)
def test_render(self):
group = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_assignment('assignment1')\
.add_group(students=[self.testfromuser]).group
invite = group.groupinvite_set.create(
sent_by=self.testfromuser,
sent_to=self.testtouser)
response = self._getas(invite.id, self.testtouser)
self.assertEquals(response.status_code, 200)
html = response.content
self.assertEquals(cssGet(html, 'h1').text.strip(), 'Respond to group inviteduck1010.active.assignment1')
def test_smart_create_no_text(self):
assignmentbuilder = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_assignment('assignment1')
group1builder = assignmentbuilder.add_group()
deadline_datetime = Deadline.reduce_datetime_precision(DateTimeBuilder.now().plus(days=10))
Deadline.objects.smart_create(
assignmentbuilder.assignment.assignmentgroups.all(),
deadline_datetime=deadline_datetime)
group1builder.reload_from_db()
self.assertEquals(group1builder.group.last_deadline.deadline, deadline_datetime)
self.assertEquals(group1builder.group.last_deadline.text, None)
def test_has_valid_grading_setup_valid_by_default(self):
assignment1 = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_assignment('assignment1').assignment
# Mock the gradingsystempluginregistry
myregistry = GradingSystemPluginRegistry()
class MockApprovedPluginApi(GradingSystemPluginInterface):
id = 'devilry_gradingsystemplugin_approved'
myregistry.add(MockApprovedPluginApi)
with patch('devilry.apps.core.models.assignment.gradingsystempluginregistry', myregistry):
self.assertTrue(assignment1.has_valid_grading_setup())
def test_autoset_last_delivery_on_group_new_successful(self):
groupbuilder = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_assignment('week1')\
.add_group()
deadline = groupbuilder\
.add_deadline_in_x_weeks(weeks=1).deadline
delivery = Delivery.objects.create(
deadline=deadline,
successful=True)
groupbuilder.reload_from_db()
self.assertEquals(groupbuilder.group.last_delivery, delivery)
self.assertEquals(delivery.last_delivery_by_group, groupbuilder.group)
def test_do_not_autoset_last_delivery_on_group_when_false(self):
groupbuilder = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_assignment('week1')\
.add_group()
deadline = groupbuilder\
.add_deadline_in_x_weeks(weeks=1).deadline
delivery = Delivery(
deadline=deadline,
successful=False)
delivery.save(autoset_last_delivery_on_group=False)
groupbuilder.reload_from_db()
self.assertEquals(groupbuilder.group.last_delivery_id, None)
def setUp(self):
self.examiner1 = UserBuilder('examiner1').user
self.assignment1builder = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_assignment('assignment1')
self.assignment1builder.assignment.setup_grading(
grading_system_plugin_id=ApprovedPluginApi.id,
points_to_grade_mapper='passed-failed',
passing_grade_min_points=1,
max_points=1)
self.assignment1builder.assignment.save()
pluginapi = ApprovedPluginApi(self.assignment1builder.assignment)
self.url = pluginapi.get_bulkedit_feedback_url(self.assignment1builder.assignment.id)
def test_smart_create_newer_exists(self):
assignmentbuilder = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_assignment('assignment1')
group1builder = assignmentbuilder.add_group()
group1builder.add_deadline_in_x_weeks(weeks=2)
self.assertEquals(group1builder.group.deadlines.count(), 1)
with self.assertRaises(NewerDeadlineExistsError):
Deadline.objects.smart_create(
assignmentbuilder.assignment.assignmentgroups.all(),
deadline_datetime=DateTimeBuilder.now().plus(days=1))
group1builder.reload_from_db()
self.assertEquals(group1builder.group.deadlines.count(), 1)
