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 create_feedbackset_structure():
def randomize_files():
return random.sample(comment_files, int(random.uniform(0, len(comment_files))))
def get_comment_text():
return comment_texts[int(random.uniform(0, len(comment_texts)))]
feedbacksetbuilder = groupbuilder.add_feedback_set(
points=random.randint(minpoints, maxpoints),
published_by=examiner,
created_by=examiner,
deadline_datetime=DateTimeBuilder.now().minus(weeks=weeks_ago),
gradeform_json="test"
)
# add student delivery
feedbacksetbuilder.add_groupcomment(
files=randomize_files(),
user=user,
user_role="student",
instant_publish=True,
visible_for_students=True,
text=get_comment_text(),
published_datetime=DateTimeBuilder.now().minus(weeks=weeks_ago, days=4))
users = [{'user': user, 'role': 'student'}, {'user': examiner, 'role': 'examiner'}]
# add random comments
for i in xrange(0, int(random.uniform(0, 5))):
random_user = users[int(random.uniform(0, 1))]
feedbacksetbuilder.add_groupcomment(
files=randomize_files(),
user=random_user['user'],
user_role=random_user['role'],
instant_publish=True,
visible_for_students=True,
text=get_comment_text(),
published_datetime=DateTimeBuilder.now().minus(weeks=weeks_ago, days=3,
hours=int(random.uniform(0, 23))))
# add examiner feedback
feedbacksetbuilder.add_groupcomment(
files=randomize_files(),
user=examiner,
user_role="examiner",
instant_publish=bool(random.getrandbits(1)),
visible_for_students=True,
text=get_comment_text(),
published_datetime=DateTimeBuilder.now().minus(weeks=weeks_ago, days=2))
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)
group1_last_delivery = Delivery.objects.filter(deadline__assignment_group=group1).first()
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)
group2_last_delivery = Delivery.objects.filter(deadline__assignment_group=group2).first()
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_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_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 build_random_pointassignmentdata(self,
periodbuilder, weeks_ago, short_name, long_name,
filecount,
feedback_percent=100,
bad_students=None, good_students=None):
bad_students_iterator = bad_students or self.bad_students.itervalues()
good_students_iterator = good_students or self.good_students.itervalues()
assignmentbuilder = periodbuilder.add_assignment_x_weeks_ago(
weeks=weeks_ago,
short_name=short_name, long_name=long_name,
passing_grade_min_points=1,
grading_system_plugin_id='devilry_gradingsystemplugin_points',
points_to_grade_mapper='raw-points',
max_points=filecount,
first_deadline=DateTimeBuilder.now().minus(weeks=weeks_ago-1)
)
def create_group(user, minpoints, maxpoints, examiner):
groupbuilder = assignmentbuilder.add_group(
students=[user], examiners=[examiner])
deadlinebuilder = groupbuilder\
.add_deadline(
deadline=Deadline.reduce_datetime_precision(assignmentbuilder.assignment.first_deadline))
deliverybuilder = deadlinebuilder.add_delivery_x_hours_before_deadline(
hours=random.randint(1, 30))
used_filenames = set()
for number in xrange(filecount):
while True:
deliveryfile = random.choice(programs)
filename = deliveryfile['filename']
if filename not in used_filenames:
used_filenames.add(filename)
break
deliverybuilder.add_filemeta(
filename=deliveryfile['filename'],
data=deliveryfile['data'])
if random.randint(0, 100) <= feedback_percent:
feedback = StaticFeedback.from_points(
assignment=assignmentbuilder.assignment,
saved_by=examiner,
delivery=deliverybuilder.delivery,
rendered_view=self._lorem_paras(random.randint(1, 5)),
points=random.randint(minpoints, maxpoints))
feedback.save()
for user in bad_students_iterator:
create_group(user, minpoints=0, maxpoints=filecount/2,
examiner=random.choice(self.examiners))
for user in good_students_iterator:
create_group(user, minpoints=filecount/2, maxpoints=filecount,
examiner=random.choice(self.examiners))
create_group(self.april, minpoints=1, maxpoints=filecount,
examiner=self.donald)
return assignmentbuilder
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_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()
last_delivery = Delivery.objects.filter(deadline__assignment_group=groupbuilder.group).first()
self.assertEquals(last_delivery, deadline.deliveries.all()[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_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_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_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_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_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_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 create_feedbackset_complete(self):
# Create a finished feedback_set for a specified user on a new subject
# and a new assingment in the current period
student = UserBuilder('psylocke', full_name='Elisabeth Braddock').user
examiner = UserBuilder('magneto', full_name='Erik Lehnsherr').user
examiner2 = UserBuilder('beast', full_name='Hank McCoy').user
first_deadline = timezone.now() - timezone.timedelta(weeks=2, days=1)
assignment_setup_gradeform_json = {
"type": "advanced",
"id": "uyagsfuyg43t763t42gtysfeg82376rf2uytf27836dgfweytfgv7238",
"schema":
[
{
"id": "uasgf87###ASDSAIDQuestion title",
"title":"Question title",
"explanation":"Explanation of how to fill in",
"options_type":"range",
"range_from": 0,
"range_to": 100,
"value": 50,
"comment": ""
},
{
"id": "uasek32002AIDQuestion title",
"title":"Question title",
"explanation":"Explanation of how to fill in",
"options_type":"single_select",
"options":
[
{"value": "false", "points": 1, "choise_text":"some choise", "comment": ""},
{"value": "false", "points": 1, "choise_text":"some choise", "comment": ""},
{"value": "false", "points": 1, "choise_text":"some choise", "comment": ""},
{"value": "false", "points": 1, "choise_text":"some choise", "comment": ""}
]
},
{
"id": "ullsoqppp987#@asdIDQuestion title",
"title":"Question title",
"explanation":"Explanation of how to fill in",
"options_type":"multi_select",
"options":
[
{"value": "false", "points": 1, "choise_text":"some choise", "comment": ""},
{"value": "false", "points": 1, "choise_text":"some choise", "comment": ""},
{"value": "false", "points": 1, "choise_text":"some choise", "comment": ""},
{"value": "false", "points": 1, "choise_text":"some choise", "comment": ""}
]
},
{
"id": "sdaikjfoa4788698236487263847iwufghQuestion title",
"title":"Question title",
"explanation":"Explanation of how to fill in",
"options_type":"feedback",
"feedback": "some written feedback in a textarea"
}
]
}
data = {
'type': 'advanced',
'scheme': [
{"points_max": "5", "points_achieved": "5", "text": "Has the student documented the code?", "comment": "Great documentation"},
{"points_max": "5", "points_achieved": "3", "text": "Implemented own datastructures?", "comment": "You where meant to implement all datastructures. You didn't implement the hashmap ='("},
{"points_max": "5", "points_achieved": "4", "text": "Has the student understood the different pros and cons for the datastructures?", "comment": "Shows good understanding"},
{"points_max": "5", "points_achieved": "0", "text": "Fullfilling designdocument?", "comment": "You where supposed to deliver a document with CONTENT, not an empty one!"},
]
}
periodbuilder = self.duckburgh.add_subject(
short_name='inf7020',
long_name='INF7020 Programming for World Domination and Crashing Non-Mutant Economy',
).add_6month_active_period(
short_name='testsemester',
long_name='Testsemester',
relatedexaminers=[
RelatedExaminer(user=examiner),
RelatedExaminer(user=examiner2),
],
relatedstudents=[student])
assignmentgroupbuilder = periodbuilder.add_assignment(
'Oblig 1 - Domination',
passing_grade_min_points=3,
max_points=10,
first_deadline=first_deadline,
gradeform_setup_json=json.dumps(assignment_setup_gradeform_json)
).add_group()
assignmentgroupbuilder.add_candidates_from_relatedstudents(
*periodbuilder.period.relatedstudent_set.all())
assignmentgroupbuilder.add_examiners(examiner, examiner2)
feedbacksetbuilder1 = assignmentgroupbuilder.add_feedback_set(
points=1,
published_by=examiner,
created_by=examiner,
published_datetime=DateTimeBuilder.now().minus(weeks=1, days=5, hours=2),
created_datetime=DateTimeBuilder.now().minus(weeks=4),
deadline_datetime=first_deadline,
gradeform_json=json.dumps(data)
)
# Event summary for feedback_set 1
feedbacksetbuilder1.add_groupcomment(
user=student,
user_role='student',
instant_publish=True,
visible_for_students=True,
text="I don't know how to solve this, can't I just use my private army?",
published_datetime=DateTimeBuilder.now().minus(weeks=2, days=2)
)
feedbacksetbuilder1.add_groupcomment(
user=examiner,
user_role='examiner',
instant_publish=True,
visible_for_students=True,
text="No no no, you're here to learn how to get domination using information "
"technology. Later you will learn to use automate your abilities by programming them.",
published_datetime=DateTimeBuilder.now().minus(weeks=2, days=2)
)
feedbacksetbuilder1.add_groupcomment(
files=[comment_files[0]],
user=student,
user_role='student',
instant_publish=True,
visible_for_students=True,
text='Here my assignment! I think I have a great solution! =D',
published_datetime=DateTimeBuilder.now().minus(weeks=2, days=1, hours=1)
)
feedbacksetbuilder1.add_groupcomment(
files=[comment_files[1]],
user=student,
user_role='student',
instant_publish=True,
visible_for_students=True,
text='Wuups! Forgot this file!',
published_datetime=DateTimeBuilder.now().minus(weeks=1, days=5, hours=3)
)
feedbacksetbuilder1.add_groupcomment(
files=[comment_files[1]],
user=examiner,
user_role='examiner',
instant_publish=True,
visible_for_students=True,
text="You failed miserably! Try to actually understand the problem. Printing 'hello world, I own you now' "
"everywhere won't get you anywhere!",
published_datetime=feedbacksetbuilder1.feedback_set.published_datetime
# DateTimeBuilder.now().minus(weeks=1, days=5, hours=1)
)
feedbacksetbuilder1.add_groupcomment(
user=student,
user_role='student',
instant_publish=True,
visible_for_students=True,
text='Noooooooo! New try pls?',
published_datetime=DateTimeBuilder.now().minus(weeks=1, days=4, hours=23)
)
feedbacksetbuilder1.add_groupcomment(
user=examiner,
user_role='examiner',
instant_publish=True,
visible_for_students=True,
text="Ok, I'll give you a second try!",
published_datetime=DateTimeBuilder.now().minus(weeks=1, days=4, hours=22)
)
# Event summary for feedback_set 2
feedbacksetbuilder2 = assignmentgroupbuilder.add_feedback_set(
points=10,
published_by=examiner,
created_by=examiner,
published_datetime=DateTimeBuilder.now().minus(weeks=0, days=3),
created_datetime=DateTimeBuilder.now().minus(weeks=1, days=4, hours=21),
deadline_datetime=DateTimeBuilder.now().minus(weeks=1),
gradeform_json=json.dumps(data)
)
feedbacksetbuilder2.add_groupcomment(
user=student,
user_role='student',
instant_publish=True,
visible_for_students=True,
text="Thanks!",
published_datetime=DateTimeBuilder.now().minus(weeks=1, days=4, hours=18)
)
feedbacksetbuilder2.add_groupcomment(
user=student,
user_role='student',
instant_publish=True,
visible_for_students=True,
text="Do you like cashew nuts?",
published_datetime=DateTimeBuilder.now().minus(weeks=1, days=4, hours=16)
)
feedbacksetbuilder2.add_groupcomment(
user=examiner,
user_role='examiner',
instant_publish=True,
visible_for_students=True,
text="Stay on topic please... But, yes...",
published_datetime=DateTimeBuilder.now().minus(weeks=1, days=3)
)
feedbacksetbuilder2.add_groupcomment(
files=[comment_files[0], comment_files[1]],
user=student,
user_role='student',
instant_publish=True,
visible_for_students=True,
text='Here we go again!',
published_datetime=DateTimeBuilder.now().minus(weeks=1, days=2)
)
feedbacksetbuilder2.add_groupcomment(
files=[comment_files[2]],
user=examiner,
user_role='examiner',
instant_publish=True,
visible_for_students=True,
text="Great job! You must be the most evil mutant I have ever met! Keep going like this, "
"and you'll own the entire planet in no time!",
published_datetime=feedbacksetbuilder2.feedback_set.published_datetime
# DateTimeBuilder.now().minus(weeks=0, days=3)
)
feedbacksetbuilder2.add_groupcomment(
user=student,
user_role='student',
instant_publish=True,
visible_for_students=True,
text="Thanks! Sorry for the first delivery, I was so hungover when I worked on that!",
published_datetime=DateTimeBuilder.now().minus(weeks=0, days=2)
)
def add_duck1100(self):
duck1100 = self.duckburgh.add_subject(
short_name='duck1100',
long_name='DUCK1100 - Programming for the natural sciences')
duck1100.add_admins(self.thor)
relatedstudents = [
RelatedStudent(user=self.april, tags='group1'),
]
relatedstudents.extend(self._as_relatedstudents(self.good_students.values(), 'group1'))
relatedstudents.extend(self._as_relatedstudents(self.bad_students.values(), 'group2'))
testsemester = duck1100.add_6month_active_period(
short_name='testsemester', long_name='Testsemester',
relatedstudents=relatedstudents,
relatedexaminers=[
RelatedExaminer(user=self.thor, tags=''),
RelatedExaminer(user=self.donald, tags='group1'),
RelatedExaminer(user=self.scrooge, tags='group2')
])
# old_relatedstudentusers = [
# self.thor,
# self.april, self.bad_students['dewey'],
# self.bad_students['louie'], self.bad_students['june'],
# self.good_students['loki'], self.good_students['kvasir']]
# old_relatedstudents = self._as_relatedstudents(old_relatedstudentusers, tags='')
oldtestsemester = duck1100.add_6month_lastyear_period(
short_name='oldtestsemester', long_name='Old testsemester',
relatedstudents=relatedstudents,
relatedexaminers=[
RelatedExaminer(user=self.thor, tags=''),
RelatedExaminer(user=self.donald, tags='group1'),
RelatedExaminer(user=self.scrooge, tags='group2')
])
for periodbuilder, weekoffset in [
(oldtestsemester, 52),
(testsemester, 0)]:
self.build_random_pointassignmentdata(
periodbuilder=periodbuilder,
weeks_ago=weekoffset + 6, filecount=4,
short_name='week1', long_name='Week 1')
self.build_random_pointassignmentdata(
periodbuilder=periodbuilder,
weeks_ago=weekoffset + 5, filecount=2,
short_name='week2', long_name='Week 2')
self.build_random_pointassignmentdata(
periodbuilder=periodbuilder,
weeks_ago=weekoffset + 4, filecount=4,
short_name='week3', long_name='Week 3')
self.build_random_pointassignmentdata(
periodbuilder=periodbuilder,
weeks_ago=weekoffset + 3, filecount=8,
short_name='week4', long_name='Week 4')
if weekoffset == 0:
self.build_random_pointassignmentdata(
periodbuilder=periodbuilder,
weeks_ago=weekoffset + 1, filecount=6,
short_name='week5', long_name='Week 5',
feedback_percent=50)
week6 = periodbuilder.add_assignment_x_weeks_ago(
weeks=weekoffset, short_name='week6', long_name='Week 6',
passing_grade_min_points=1,
grading_system_plugin_id='devilry_gradingsystemplugin_points',
points_to_grade_mapper='raw-points',
max_points=6
)
for user in self.allstudentslist + [self.april]:
examiner = random.choice(self.examiners)
week6 \
.add_group(students=[user], examiners=[examiner]) \
.add_deadline(deadline=Deadline.reduce_datetime_precision(DateTimeBuilder.now().plus(days=7)))
else:
self.build_random_pointassignmentdata(
periodbuilder=periodbuilder,
weeks_ago=weekoffset + 1, filecount=1,
short_name='week5', long_name='Week 5')
self.build_random_pointassignmentdata(
periodbuilder=periodbuilder,
weeks_ago=weekoffset, filecount=2,
short_name='week6', long_name='Week 6')
print
print("*" * 70)
print
print('duck1100 added')
print
print("*" * 70)
print
def build_random_pointassignmentdata(self,
periodbuilder, weeks_ago, short_name, long_name,
filecount,
feedback_percent=100,
bad_students=None, good_students=None):
bad_students_iterator = bad_students or self.bad_students.itervalues()
good_students_iterator = good_students or self.good_students.itervalues()
assignmentbuilder = periodbuilder.add_assignment_x_weeks_ago(
weeks=weeks_ago,
short_name=short_name, long_name=long_name,
passing_grade_min_points=1,
grading_system_plugin_id='devilry_gradingsystemplugin_points',
points_to_grade_mapper='raw-points',
max_points=filecount,
first_deadline=DateTimeBuilder.now().minus(weeks=weeks_ago - 1)
)
def create_group(user, minpoints, maxpoints, examiner):
def create_old_delivery_structure():
deadlinebuilder = groupbuilder \
.add_deadline(
deadline=Deadline.reduce_datetime_precision(
assignmentbuilder.assignment.first_deadline))
deliverybuilder = deadlinebuilder.add_delivery_x_hours_before_deadline(
hours=random.randint(1, 30))
used_filenames = set()
for number in xrange(filecount):
while True:
deliveryfile = random.choice(programs)
filename = deliveryfile['filename']
if filename not in used_filenames:
used_filenames.add(filename)
break
deliverybuilder.add_filemeta(
filename=deliveryfile['filename'],
data=deliveryfile['data'])
if random.randint(0, 100) <= feedback_percent:
feedback = StaticFeedback.from_points(
assignment=assignmentbuilder.assignment,
saved_by=examiner,
delivery=deliverybuilder.delivery,
rendered_view=self._lorem_paras(random.randint(1, 5)),
points=random.randint(minpoints, maxpoints))
feedback.save()
def create_feedbackset_structure():
def randomize_files():
return random.sample(comment_files, int(random.uniform(0, len(comment_files))))
def get_comment_text():
return comment_texts[int(random.uniform(0, len(comment_texts)))]
feedbacksetbuilder = groupbuilder.add_feedback_set(
points=random.randint(minpoints, maxpoints),
published_by=examiner,
created_by=examiner,
deadline_datetime=DateTimeBuilder.now().minus(weeks=weeks_ago),
gradeform_json="test"
)
# add student delivery
feedbacksetbuilder.add_groupcomment(
files=randomize_files(),
user=user,
user_role="student",
instant_publish=True,
visible_for_students=True,
text=get_comment_text(),
published_datetime=DateTimeBuilder.now().minus(weeks=weeks_ago, days=4))
users = [{'user': user, 'role': 'student'}, {'user': examiner, 'role': 'examiner'}]
# add random comments
for i in xrange(0, int(random.uniform(0, 5))):
random_user = users[int(random.uniform(0, 1))]
feedbacksetbuilder.add_groupcomment(
files=randomize_files(),
user=random_user['user'],
user_role=random_user['role'],
instant_publish=True,
visible_for_students=True,
text=get_comment_text(),
published_datetime=DateTimeBuilder.now().minus(weeks=weeks_ago, days=3,
hours=int(random.uniform(0, 23))))
# add examiner feedback
feedbacksetbuilder.add_groupcomment(
files=randomize_files(),
user=examiner,
user_role="examiner",
instant_publish=bool(random.getrandbits(1)),
visible_for_students=True,
text=get_comment_text(),
published_datetime=DateTimeBuilder.now().minus(weeks=weeks_ago, days=2))
try:
relatedstudent = RelatedStudent.objects.get(period=assignmentbuilder.assignment.period,
user=user)
except:
print()
print("*" * 70)
print()
print(user)
print()
print("*" * 70)
print()
raise
groupbuilder = assignmentbuilder.add_group(
relatedstudents=[relatedstudent], examiners=[examiner])
if weeks_ago > 52:
create_old_delivery_structure()
else:
create_feedbackset_structure()
for user in bad_students_iterator:
create_group(user, minpoints=0, maxpoints=filecount / 2,
examiner=random.choice(self.examiners))
for user in good_students_iterator:
create_group(user, minpoints=filecount / 2, maxpoints=filecount,
examiner=random.choice(self.examiners))
create_group(self.april, minpoints=1, maxpoints=filecount,
examiner=self.donald)
return assignmentbuilder
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)
