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 test_set_last_deadline_on_group_newest(self):
groupbuilder = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_assignment('assignment1')\
.add_group()
self.assertIsNone(groupbuilder.group.last_deadline)
deadline2 = groupbuilder.group.deadlines.create(deadline=DateTimeBuilder.now().plus(days=10))
deadline1 = groupbuilder.group.deadlines.create(deadline=DateTimeBuilder.now().plus(days=5))
groupbuilder.reload_from_db()
self.assertEquals(groupbuilder.group.last_deadline, deadline2)
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 test_set_last_deadline_on_group_copy(self):
groupbuilder = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_assignment('assignment1')\
.add_group()
self.assertIsNone(groupbuilder.group.last_deadline)
deadline2 = Deadline(assignment_group=groupbuilder.group, deadline=DateTimeBuilder.now().plus(days=10))
deadline1 = Deadline(assignment_group=groupbuilder.group, deadline=DateTimeBuilder.now().plus(days=5))
# Copy cleans deadlines before save, so we have to do that for the assertEquals below to match
for deadline in deadline1, deadline2:
deadline.clean()
deadline.save()
groupbuilder.reload_from_db()
groupcopy = groupbuilder.group.copy_all_except_candidates()
self.assertEquals(groupcopy.last_deadline.deadline, deadline2.deadline)
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_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_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_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_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_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)
def test_default_success_url(self):
group1builder = self.assignment1builder\
.add_group(examiners=[self.examiner1])
deadline_datetime = Deadline.reduce_datetime_precision(DateTimeBuilder.now().plus(days=10))
response = self._postas(self.examiner1, {
'group_ids': [group1builder.group.id],
'deadline': isoformat_datetime(deadline_datetime),
'text': 'Hello world',
'add_deadline_form': 'i18nlabel'
})
self.assertEquals(response.status_code, 302)
self.assertTrue(response['Location'].endswith(
reverse('devilry_examiner_allgroupsoverview', kwargs={'assignmentid': self.assignment1builder.assignment.id})))
def test_custom_success_url(self):
group1builder = self.assignment1builder\
.add_group(examiners=[self.examiner1])
deadline_datetime = Deadline.reduce_datetime_precision(DateTimeBuilder.now().plus(days=10))
response = self._postas(self.examiner1, {
'group_ids': [group1builder.group.id],
'deadline': isoformat_datetime(deadline_datetime),
'text': 'Hello world',
'success_url': '/my/test',
'add_deadline_form': 'i18nlabel'
})
self.assertEquals(response.status_code, 302)
self.assertTrue(response['Location'].endswith('/my/test'))
def test_post_why_created(self):
group1builder = self.assignment1builder\
.add_group(examiners=[self.examiner1])
deadline_datetime = Deadline.reduce_datetime_precision(DateTimeBuilder.now().plus(days=10))
response = self._postas(self.examiner1, {
'group_ids': [group1builder.group.id],
'deadline': isoformat_datetime(deadline_datetime),
'text': 'Hello world',
'why_created': 'examiner-gave-another-chance',
'add_deadline_form': 'i18nlabel'
})
self.assertEquals(response.status_code, 302)
group1builder.reload_from_db()
self.assertEquals(group1builder.group.last_deadline.why_created, 'examiner-gave-another-chance')
def test_post_no_text(self):
group1builder = self.assignment1builder\
.add_group(examiners=[self.examiner1])
deadline_datetime = Deadline.reduce_datetime_precision(DateTimeBuilder.now().plus(days=10))
response = self._postas(self.examiner1, {
'group_ids': [group1builder.group.id],
'deadline': isoformat_datetime(deadline_datetime),
'add_deadline_form': 'i18nlabel',
'no_text': 'on'
})
self.assertEquals(response.status_code, 302)
group1builder.reload_from_db()
self.assertEquals(group1builder.group.last_deadline.deadline, deadline_datetime)
self.assertEquals(group1builder.group.last_deadline.text, '')
def test_post_no_text_checkbox_required(self):
group1builder = self.assignment1builder\
.add_group(examiners=[self.examiner1])
deadline_datetime = Deadline.reduce_datetime_precision(DateTimeBuilder.now().plus(days=10))
response = self._postas(self.examiner1, {
'group_ids': [group1builder.group.id],
'deadline': isoformat_datetime(deadline_datetime),
'add_deadline_form': 'i18nlabel'
})
self.assertEquals(response.status_code, 200)
group1builder.reload_from_db()
self.assertEquals(group1builder.group.last_deadline, None)
self.assertIn('You must specify an "About this deadline" message, or select that you do not want to specify a message.',
response.content)
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_post_no_text_checked_and_text_provided(self):
group1builder = self.assignment1builder\
.add_group(examiners=[self.examiner1])
deadline_datetime = Deadline.reduce_datetime_precision(DateTimeBuilder.now().plus(days=10))
response = self._postas(self.examiner1, {
'group_ids': [group1builder.group.id],
'deadline': isoformat_datetime(deadline_datetime),
'add_deadline_form': 'i18nlabel',
'no_text': 'on',
'text': 'Test'
})
self.assertEquals(response.status_code, 200)
group1builder.reload_from_db()
self.assertEquals(group1builder.group.last_deadline, None)
self.assertIn('If you do not want to provide an "About this deadline" message, you have to clear the text field.',
response.content)
def test_render(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)
response = self._getas(assignment1builder.assignment.id, self.testuser)
self.assertEquals(response.status_code, 200)
html = response.content
self.assertEquals(cssGet(html, 'input[name=long_name]')['value'], 'Assignment One')
self.assertEquals(cssGet(html, 'select[name=deadline_handling] option[value=1]')['selected'], 'selected')
self.assertEquals(cssGet(html, 'input[name=publishing_time]')['value'],
isoformat_datetime(publishing_time))
self.assertEquals(cssGet(html, 'input[name=short_name]')['value'], 'assignment1')
def test_smart_create_electronic(self):
assignmentbuilder = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_assignment('assignment1')
group1builder = assignmentbuilder.add_group()
group2builder = assignmentbuilder.add_group()
deadline_datetime = Deadline.reduce_datetime_precision(DateTimeBuilder.now().plus(days=10))
result = Deadline.objects.smart_create(
assignmentbuilder.assignment.assignmentgroups.all(),
deadline_datetime=deadline_datetime,
text='Hello world')
self.assertIsNone(result)
group1builder.reload_from_db()
self.assertEquals(group1builder.group.deadlines.count(), 1)
created_deadline = group1builder.group.deadlines.all()[0]
self.assertEquals(created_deadline.deadline, deadline_datetime)
self.assertEquals(created_deadline.text, 'Hello world')
self.assertEquals(group1builder.group.last_deadline, created_deadline)
self.assertEquals(group1builder.group.last_deadline.deliveries.count(), 0)
group2builder.reload_from_db()
self.assertEquals(group2builder.group.deadlines.all()[0].deadline, deadline_datetime)
self.assertEquals(group2builder.group.last_deadline, group2builder.group.deadlines.all()[0])
def test_students_can_create_groups_now_true_and_future(self):
self.group.parentnode.students_can_create_groups = True
self.group.parentnode.students_can_not_create_groups_after = DateTimeBuilder.now().minus(days=2)
self.group.parentnode.save()
content, response = self._getas('student1')
self.assertFalse(content['students_can_create_groups_now'])
def test_do_not_autocreate_delivery_if_electronic(self):
groupbuilder = PeriodBuilder.quickadd_ducku_duck1010_active()\
.add_assignment('assignment1')\
.add_group()
deadline = groupbuilder.group.deadlines.create(deadline=DateTimeBuilder.now().plus(days=10))
self.assertEquals(deadline.deliveries.count(), 0)
