def test_feedbackset_created_with_published_feedbackset_with_comment(self):
group = mommy.make('core.AssignmentGroup')
examiner = mommy.make('core.Examiner',
assignmentgroup=group,
relatedexaminer=mommy.make('core.RelatedExaminer'))
group_mommy.feedbackset_first_attempt_published(group=examiner.assignmentgroup,
grading_published_by=examiner.relatedexaminer.user)
timestr = (datetimeutils.get_current_datetime() + timezone.timedelta(days=2)).strftime('%Y-%m-%d %H:%M')
comment_text = 'New attempt given'
self.mock_http302_postrequest(
cradmin_role=examiner.assignmentgroup,
requestuser=examiner.relatedexaminer.user,
viewkwargs={'pk': examiner.assignmentgroup.id},
requestkwargs={
'data': {
'deadline_datetime': timestr,
'text': comment_text,
'examiner_create_new_feedbackset': 'unused value',
}
})
feedbacksets = group_models.FeedbackSet.objects.all()
self.assertEquals(2, len(feedbacksets))
self.assertEquals(datetime.strptime(timestr, '%Y-%m-%d %H:%M'), feedbacksets[1].deadline_datetime)
comments = group_models.GroupComment.objects.all()
self.assertEquals(1, len(comments))
self.assertEquals(comments[0].feedback_set_id, feedbacksets[1].id)
self.assertEquals(comments[0].text, comment_text)
def test_feedbackset_ordering_get_as_list(self):
# Must be refactored
# Tests the ordering of FeedbackFeedSidebarBuilder
testuser = mommy.make(settings.AUTH_USER_MODEL)
testgroup = mommy.make('core.AssignmentGroup')
testfeedbackset = devilry_group_mommy_factories.feedbackset_first_attempt_published(
group=testgroup,
deadline_datetime=timezone.now() - timezone.timedelta(days=1),
is_last_in_group=None)
testfeedbackset1 = devilry_group_mommy_factories.feedbackset_first_attempt_published(
group=testgroup,
deadline_datetime=timezone.now() + timezone.timedelta(days=2))
testcomment = mommy.make('devilry_group.GroupComment', feedback_set=testfeedbackset)
mommy.make('devilry_comment.CommentFile',
comment=testcomment)
testcomment1 = mommy.make('devilry_group.GroupComment', feedback_set=testfeedbackset1)
mommy.make('devilry_comment.CommentFile',
comment=testcomment1)
feedbackset_queryset = builder_base.get_feedbackfeed_builder_queryset(testgroup, testuser, 'unused')
sidebarbuilder = FeedbackFeedSidebarBuilder(feedbacksets=feedbackset_queryset)
sidebarbuilder.build()
sidebarlist = sidebarbuilder.get_as_list()
self.assertTrue(
sidebarlist[0]['feedbackset'].current_deadline() < sidebarlist[1]['feedbackset'].current_deadline())
def test_bulk_send_emails_message_and_messagereceivers_created(self):
new_deadline = datetime.utcnow()
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start',
long_name='Assignment 1')
testgroup1 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
testgroup2 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
testgroup3 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
test_fb1 = group_mommy.feedbackset_first_attempt_published(
group=testgroup1, grading_points=1, deadline_datetime=new_deadline)
test_fb2 = group_mommy.feedbackset_first_attempt_published(
group=testgroup2, grading_points=1, deadline_datetime=new_deadline)
test_fb3 = group_mommy.feedbackset_first_attempt_published(
group=testgroup3, grading_points=1, deadline_datetime=new_deadline)
student1 = mommy.make('core.Candidate', assignment_group=testgroup1)
mommy.make('devilry_account.UserEmail', user=student1.relatedstudent.user, email='*****@*****.**')
student2 = mommy.make('core.Candidate', assignment_group=testgroup2)
mommy.make('devilry_account.UserEmail', user=student2.relatedstudent.user, email='*****@*****.**')
student3 = mommy.make('core.Candidate', assignment_group=testgroup3)
mommy.make('devilry_account.UserEmail', user=student3.relatedstudent.user, email='*****@*****.**')
deadline_email.bulk_send_deadline_moved_email(
assignment_id=testassignment.id,
feedbackset_id_list=[test_fb1.id, test_fb2.id, test_fb3.id],
domain_url_start='http://www.example.com/')
self.assertEqual(len(mail.outbox), 3)
self.assertEqual(Message.objects.count(), 3)
self.assertEqual(MessageReceiver.objects.count(), 3)
def test_post_from_previous_view_selected_groups_are_hidden(self):
# By adding the post_type_received_data to the key, we are simulating that the
# post comes from a different view.
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
testgroup1 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
group_mommy.feedbackset_first_attempt_published(group=testgroup1)
testgroup2 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
group_mommy.feedbackset_first_attempt_published(group=testgroup2)
testuser = self._get_admin_user(testassignment.parentnode)
mommy.make('core.Examiner', assignmentgroup=testgroup1, relatedexaminer__user=testuser)
mommy.make('core.Examiner', assignmentgroup=testgroup2, relatedexaminer__user=testuser)
mockresponse = self.mock_http200_postrequest_htmls(
cradmin_role=testassignment,
cradmin_instance=self._get_mock_instance(testassignment),
cradmin_app=self._get_mock_app(user=testuser),
requestuser=testuser,
viewkwargs={
'deadline': datetimeutils.datetime_to_url_string(testassignment.first_deadline),
'handle_deadline': self.handle_deadline
},
requestkwargs={
'data': {
'post_type_received_data': '',
'selected_items': [testgroup1.id, testgroup2.id]
}
}
)
self.assertIn('type="hidden"', mockresponse.selector.one('#id_selected_items_0').__str__().decode('utf-8'))
self.assertIn('type="hidden"', mockresponse.selector.one('#id_selected_items_1').__str__().decode('utf-8'))
self.assertIn('value="{}"'.format(testgroup1.id), mockresponse.selector.one('#id_selected_items_0').__str__().decode('utf-8'))
self.assertIn('value="{}"'.format(testgroup2.id), mockresponse.selector.one('#id_selected_items_1').__str__().decode('utf-8'))
def test_updated_grading_points_event_no_updates(self):
testuser = mommy.make(settings.AUTH_USER_MODEL)
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_end')
testgroup = mommy.make('core.AssignmentGroup', parentnode=testassignment)
group_mommy.feedbackset_first_attempt_published(group=testgroup)
timeline_list = self.__build_timeline(group=testgroup, user=testuser, assignment=testassignment)
self.assertEqual(len(timeline_list[0]['feedbackset_events']), 1)
def test_get_num_elements_in_timeline(self):
testuser = mommy.make(settings.AUTH_USER_MODEL)
assignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
group = mommy.make('core.AssignmentGroup', parentnode=assignment)
now = timezone.now()
group_mommy.feedbackset_first_attempt_published(
group=group,
is_last_in_group=None,
created_datetime=now - timezone.timedelta(days=20),
grading_published_datetime=now-timezone.timedelta(days=19))
group_mommy.feedbackset_new_attempt_published(
group=group,
is_last_in_group=None,
created_datetime=now - timezone.timedelta(days=18),
deadline_datetime=now-timezone.timedelta(days=17),
grading_published_datetime=now-timezone.timedelta(days=16))
group_mommy.feedbackset_new_attempt_published(
group=group,
is_last_in_group=None,
created_datetime=now - timezone.timedelta(days=15),
deadline_datetime=now-timezone.timedelta(days=14),
grading_published_datetime=now-timezone.timedelta(days=13))
group_mommy.feedbackset_new_attempt_published(
group=group,
created_datetime=now - timezone.timedelta(days=12),
deadline_datetime=now-timezone.timedelta(days=11),
grading_published_datetime=now-timezone.timedelta(days=10))
timelinebuilder = FeedbackFeedTimelineBuilder(group=group, requestuser=testuser, devilryrole='unused')
timelinebuilder.build()
self.assertEquals(11, len(timelinebuilder.timeline))
def test_get_student_can_not_see_comments_part_of_grading_before_publish_new_attempt(self):
assignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
group = mommy.make('core.AssignmentGroup',
parentnode=assignment)
group_mommy.feedbackset_first_attempt_published(
group=group,
is_last_in_group=None)
feedbackset_last = group_mommy.feedbackset_new_attempt_unpublished(
group=group,
deadline_datetime=timezone.now()+timezone.timedelta(days=1))
candidate = mommy.make('core.Candidate',
assignment_group=group,
relatedstudent=mommy.make('core.RelatedStudent'))
examiner = mommy.make('core.Examiner',
assignmentgroup=group,
relatedexaminer=mommy.make('core.RelatedExaminer', user__fullname='John Doe'),)
mommy.make('devilry_group.GroupComment',
text='asd',
part_of_grading=True,
user=examiner.relatedexaminer.user,
user_role='examiner',
feedback_set=feedbackset_last)
mockresponse = self.mock_http200_getrequest_htmls(cradmin_role=candidate.assignment_group,
requestuser=candidate.relatedstudent.user)
self.assertFalse(mockresponse.selector.exists('.devilry-group-feedbackfeed-comment'))
def test_send_to_multiple_feedbacksets(self):
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
testgroup1 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
testgroup2 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
testgroup3 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
test_feedbackset1 = group_mommy.feedbackset_first_attempt_published(group=testgroup1)
test_feedbackset2 = group_mommy.feedbackset_first_attempt_published(group=testgroup2)
test_feedbackset3 = group_mommy.feedbackset_first_attempt_published(group=testgroup3)
student1 = mommy.make('core.Candidate', assignment_group=testgroup1)
student2 = mommy.make('core.Candidate', assignment_group=testgroup2)
student3 = mommy.make('core.Candidate', assignment_group=testgroup3)
mommy.make('devilry_account.UserEmail', user=student1.relatedstudent.user, email='*****@*****.**')
mommy.make('devilry_account.UserEmail', user=student2.relatedstudent.user, email='*****@*****.**')
mommy.make('devilry_account.UserEmail', user=student3.relatedstudent.user, email='*****@*****.**')
user = mommy.make(settings.AUTH_USER_MODEL)
mommy.make('core.Examiner', assignmentgroup=testgroup1, relatedexaminer__user=user)
mommy.make('core.Examiner', assignmentgroup=testgroup2, relatedexaminer__user=user)
mommy.make('core.Examiner', assignmentgroup=testgroup3, relatedexaminer__user=user)
bulk_send_feedback_created_email(
assignment_id=testassignment.id,
feedbackset_id_list=[test_feedbackset1.id, test_feedbackset2.id, test_feedbackset3.id],
domain_url_start='http://www.example.com/')
self.assertEqual(len(mail.outbox), 3)
self.assertEqual(Message.objects.count(), 3)
self.assertEqual(MessageReceiver.objects.count(), 3)
receiver_users = [receiver.user for receiver in MessageReceiver.objects.all()]
self.assertIn(student1.relatedstudent.user, receiver_users)
self.assertIn(student2.relatedstudent.user, receiver_users)
self.assertIn(student3.relatedstudent.user, receiver_users)
def test_post_groups_published_raises_error(self):
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
testgroup1 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
testgroup2 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
group_mommy.feedbackset_first_attempt_published(group=testgroup1)
group_mommy.feedbackset_first_attempt_unpublished(group=testgroup2)
testuser = self._get_admin_user(testassignment.parentnode)
mommy.make('core.Examiner', assignmentgroup=testgroup1, relatedexaminer__user=testuser)
mommy.make('core.Examiner', assignmentgroup=testgroup2, relatedexaminer__user=testuser)
new_deadline = timezone.now() + timezone.timedelta(days=3)
new_deadline = new_deadline.replace(microsecond=0)
with self.assertRaises(http.Http404):
self.mock_http302_postrequest(
cradmin_role=testassignment,
cradmin_instance=self._get_mock_instance(testassignment),
cradmin_app=self._get_mock_app(user=testuser),
requestuser=testuser,
viewkwargs={
'deadline': datetimeutils.datetime_to_url_string(testassignment.first_deadline),
'handle_deadline': self.handle_deadline
},
requestkwargs={
'data': {
'new_deadline': isoformat_withseconds(timezone.localtime(new_deadline)),
'comment_text': 'You have been given a new attempt.',
'selected_items': [testgroup1.id, testgroup2.id]
}
}
)
self.assertEqual(2, group_models.FeedbackSet.objects.count())
def test_serialize(self):
# Test serialization of the entire GroupFeedbackSetList.
# Create AssignmentGroup
testgroup1 = mommy.make('core.AssignmentGroup')
testgroup2 = mommy.make('core.AssignmentGroup')
# Create examiner
testexaminer = mommy.make(settings.AUTH_USER_MODEL, shortname='donduc', fullname='Donald Duck')
# Create FeedbackSet
test_feedbackset1 = devilry_group_mommy_factories.feedbackset_first_attempt_published(
grading_points=1,
grading_published_by=testexaminer,
group=testgroup1
)
test_feedbackset2 = devilry_group_mommy_factories.feedbackset_first_attempt_published(
grading_points=1,
grading_published_by=testexaminer,
group=testgroup2
)
groupfeedbacksetlist = groups_groupedby_relatedstudent_and_assignments.GroupFeedbackSetList()
groupfeedbacksetlist.append((testgroup1, test_feedbackset1))
groupfeedbacksetlist.append((testgroup2, test_feedbackset2))
serialized = groupfeedbacksetlist.serialize()
self.assertEqual(2, len(serialized))
self.assertEqual(serialized[0]['id'], testgroup1.id)
self.assertEqual(serialized[1]['id'], testgroup2.id)
def test_get_render_form_selected_items_selected_students_passing_grade_on_assignment(self):
testperiod = mommy.make('core.Period')
relatedstudent1 = mommy.make('core.RelatedStudent', period=testperiod)
relatedstudent2 = mommy.make('core.RelatedStudent', period=testperiod)
mommy.make('core.RelatedStudent', period=testperiod)
otherassignment = mommy.make('core.Assignment', parentnode=testperiod,
passing_grade_min_points=1)
candidate1 = mommy.make('core.Candidate',
relatedstudent=relatedstudent1,
assignment_group__parentnode=otherassignment)
devilry_group_mommy_factories.feedbackset_first_attempt_published(
group=candidate1.assignment_group,
grading_points=1)
mommy.make('core.Candidate',
relatedstudent=relatedstudent2,
assignment_group__parentnode=otherassignment)
testassignment = mommy.make('core.Assignment', parentnode=testperiod)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testassignment,
requestkwargs={
'data': {'assignment': otherassignment.id}
},
viewkwargs={'selected_students': create_groups.ConfirmView.SELECTED_STUDENTS_PASSING_GRADE_ON_ASSIGNMENT})
selected_relatedstudent_ids = [
element['value']
for element in mockresponse.selector.list(
'#devilry_admin_create_groups_confirm_form input[name=selected_items]')]
self.assertEqual(
{str(relatedstudent1.id)},
set(selected_relatedstudent_ids))
def test_status_is_corrected(self):
devilry_group_mommy_factories.feedbackset_first_attempt_published(
grading_points=1)
testgroup = AssignmentGroup.objects.annotate_with_is_corrected().first()
selector = htmls.S(groupdetails.GroupDetailsRenderable(value=testgroup,
assignment=testgroup.assignment).render())
self.assertFalse(selector.exists('.devilry-cradmin-groupitemvalue-status'))
def test_grouplist_status_waiting_for_feedback_sanity(self):
testuser = mommy.make(settings.AUTH_USER_MODEL)
testperiod = mommy.make_recipe('devilry.apps.core.period_active')
testgroup = mommy.make('core.AssignmentGroup',
parentnode=mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start',
parentnode=testperiod))
mommy.make('core.Candidate',
relatedstudent__user=testuser,
assignment_group=testgroup)
devilry_group_mommy_factories.feedbackset_first_attempt_published(
group=testgroup, grading_points=3)
devilry_group_mommy_factories.feedbackset_new_attempt_unpublished(
group=testgroup,
deadline_datetime=timezone.now() - timedelta(days=2))
mockresponse = self.mock_http200_getrequest_htmls(
requestuser=testuser, cradmin_role=testperiod)
self.assertFalse(
mockresponse.selector.exists(
'.devilry-cradmin-groupitemvalue '
'.devilry-cradmin-groupitemvalue-grade'))
self.assertEqual(
'Status: waiting for feedback',
mockresponse.selector.one(
'.devilry-cradmin-groupitemvalue '
'.devilry-cradmin-groupitemvalue-status').alltext_normalized)
def test_students_in_same_group_points_for_assignment(self):
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup', parentnode=testassignment)
# Student donald
donald_user = mommy.make(settings.AUTH_USER_MODEL, fullname='Donald', shortname='donald')
relatedstudent_donald = mommy.make('core.RelatedStudent', period=testassignment.parentnode, user=donald_user)
mommy.make('core.Candidate', assignment_group=testgroup, relatedstudent=relatedstudent_donald)
# Student april
april_user = mommy.make(settings.AUTH_USER_MODEL, fullname='April', shortname='april')
relatedstudent_april = mommy.make('core.RelatedStudent', period=testassignment.parentnode, user=april_user)
mommy.make('core.Candidate', assignment_group=testgroup, relatedstudent=relatedstudent_april)
group_factory.feedbackset_first_attempt_published(group=testgroup, grading_points=10)
# Run collector
collector = PeriodAllResultsCollector(
period=testassignment.parentnode,
related_student_ids=[relatedstudent_donald.id, relatedstudent_april.id]
)
self.assertEqual(
10,
collector.results[relatedstudent_donald.id].get_result_for_assignment(testassignment.id))
self.assertEqual(
10,
collector.results[relatedstudent_april.id].get_result_for_assignment(testassignment.id))
def test_querycount(self):
testuser = mommy.make(settings.AUTH_USER_MODEL)
testperiod = mommy.make_recipe('devilry.apps.core.period_active')
testassignment1 = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start',
parentnode=testperiod)
testassignment2 = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start',
parentnode=testperiod)
loops = overview.PeriodOverviewView.paginate_by / 2
for number in range(int(round(loops))):
group1 = mommy.make('core.AssignmentGroup', parentnode=testassignment1)
mommy.make('core.Examiner', assignmentgroup=group1)
mommy.make('core.Candidate', relatedstudent__user=testuser, assignment_group=group1)
devilry_group_mommy_factories.feedbackset_first_attempt_published(
group=group1, grading_points=1)
group2 = mommy.make('core.AssignmentGroup', parentnode=testassignment2)
mommy.make('core.Examiner', assignmentgroup=group2)
mommy.make('core.Candidate', relatedstudent__user=testuser, assignment_group=group2)
devilry_group_mommy_factories.feedbackset_first_attempt_published(
group=group2, grading_points=1)
with self.assertNumQueries(4):
mockresponse = self.mock_http200_getrequest_htmls(requestuser=testuser, cradmin_role=testperiod)
self.assertEqual(
loops * 2,
self.__get_assignment_count(selector=mockresponse.selector))
def test_on_feedbackset_new_attempt_no_deadline_history_created(self):
assignment = mommy.make('core.Assignment')
group = mommy.make('core.AssignmentGroup', parentnode=assignment)
group_mommy.feedbackset_first_attempt_published(group=group)
group_mommy.feedbackset_new_attempt_unpublished(
group=group,
deadline_datetime=timezone.now() + timezone.timedelta(days=1))
self.assertEqual(0, FeedbackSetDeadlineHistory.objects.count())
def test_get_examiner_first_attempt_feedback_tab_does_not_exist_if_last_feedbackset_is_published(self):
testgroup = mommy.make('core.AssignmentGroup')
group_mommy.feedbackset_first_attempt_published(group=testgroup)
examiner = mommy.make('core.Examiner', assignmentgroup=testgroup)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testgroup,
requestuser=examiner.relatedexaminer.user
)
self.assertFalse(mockresponse.selector.exists('.devilry-group-feedbackfeed-feedback-button'))
def test_redirect_on_last_feedbackset_published(self):
group = mommy.make('core.AssignmentGroup')
examiner = mommy.make('core.Examiner',
assignmentgroup=group,
relatedexaminer=mommy.make('core.RelatedExaminer'))
group_mommy.feedbackset_first_attempt_published(group=examiner.assignmentgroup)
mockresponse = self.mock_getrequest(cradmin_role=examiner.assignmentgroup,
requestuser=examiner.relatedexaminer.user)
self.assertEquals(mockresponse.response.status_code, 302)
def test_get_feedbackset_header_grading_info_failed(self):
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup', parentnode=testassignment)
group_mommy.feedbackset_first_attempt_published(group=testgroup, grading_points=0)
examiner = mommy.make('core.Examiner', assignmentgroup=testgroup)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testgroup,
requestuser=examiner.relatedexaminer.user,
)
self.assertEqual(mockresponse.selector.one('.header-grading-info').alltext_normalized, 'failed (0/1)')
def test_404_on_last_feedbackset_published(self):
testgroup = mommy.make('core.AssignmentGroup')
examiner = mommy.make('core.Examiner',
assignmentgroup=testgroup,
relatedexaminer=mommy.make('core.RelatedExaminer'))
group_mommy.feedbackset_first_attempt_published(group=testgroup)
with self.assertRaises(Http404):
self.mock_getrequest(
cradmin_role=examiner.assignmentgroup,
requestuser=examiner.relatedexaminer.user)
def test_no_redirect_on_last_feedbackset_published(self):
group = mommy.make('core.AssignmentGroup')
examiner = mommy.make('core.Examiner',
assignmentgroup=group,
relatedexaminer=mommy.make('core.RelatedExaminer'))
group_mommy.feedbackset_first_attempt_published(group=examiner.assignmentgroup)
mockresponse = self.mock_http200_getrequest_htmls(cradmin_role=examiner.assignmentgroup,
requestuser=examiner.relatedexaminer.user)
self.assertEquals(mockresponse.selector.one('title').alltext_normalized,
examiner.assignmentgroup.assignment.get_path())
def test_grade_students_can_see_points_false(self):
devilry_group_mommy_factories.feedbackset_first_attempt_published(
group__parentnode__students_can_see_points=False,
grading_points=1)
testgroup = AssignmentGroup.objects.first()
selector = htmls.S(groupdetails.GroupDetailsRenderable(
value=testgroup, assignment=testgroup.assignment).render())
self.assertEqual(
'Grade: passed (1/1)',
selector.one('.devilry-cradmin-groupitemvalue-grade').alltext_normalized)
def test_redirect_on_last_feedbackset_unpublished_multiple_feedbacksets(self):
group = mommy.make('core.AssignmentGroup')
examiner = mommy.make('core.Examiner',
assignmentgroup=group,
relatedexaminer=mommy.make('core.RelatedExaminer'))
group_mommy.feedbackset_first_attempt_published(group=examiner.assignmentgroup, is_last_in_group=None)
group_mommy.feedbackset_new_attempt_published(group=examiner.assignmentgroup, is_last_in_group=None)
group_mommy.feedbackset_new_attempt_unpublished(group=examiner.assignmentgroup)
mockresponse = self.mock_getrequest(cradmin_role=examiner.assignmentgroup)
self.assertEquals(302, mockresponse.response.status_code)
def test_raises_404_last_feedbackset_is_not_last_published_feedbackset(self):
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup', parentnode=testassignment)
group_mommy.feedbackset_first_attempt_published(group=testgroup)
unpublished_feedbackset = group_mommy.feedbackset_new_attempt_unpublished(group=testgroup, deadline_datetime=timezone.now())
with self.assertRaises(Http404):
self.mock_http200_getrequest_htmls(
cradmin_role=testgroup,
viewkwargs={
'pk': unpublished_feedbackset.id
})
def test_get_event_two_feedbacksets_deadlines_expired_assignment_firstdeadline(self):
assignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start',
first_deadline=timezone.now() - timezone.timedelta(days=4))
testgroup = mommy.make('core.AssignmentGroup', parentnode=assignment)
group_mommy.feedbackset_first_attempt_published(group=testgroup)
group_mommy.feedbackset_new_attempt_unpublished(
group=testgroup,
deadline_datetime=timezone.now() - timezone.timedelta(days=2))
mockresponse = self.mock_http200_getrequest_htmls(cradmin_role=testgroup)
expired = mockresponse.selector.list('.devilry-group-feedbackfeed-event-message__deadline-expired')
self.assertEqual(2, len(expired))
self.assertEqual(2, group_models.FeedbackSet.objects.count())
def test_get_feedbackset_header_two_attempts(self):
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup', parentnode=testassignment)
group_mommy.feedbackset_first_attempt_published(group=testgroup)
group_mommy.feedbackset_new_attempt_unpublished(group=testgroup)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testgroup,
)
self.assertEqual(mockresponse.selector.list('.header-attempt-number')[0].alltext_normalized,
'Attempt 1')
self.assertEqual(mockresponse.selector.list('.header-attempt-number')[1].alltext_normalized,
'Attempt 2')
def test_anonymizationmode_fully_anonymous_departmentadmin_has_grade(self):
testuser = mommy.make(settings.AUTH_USER_MODEL)
testgroup = mommy.make('core.AssignmentGroup',
parentnode=mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start',
anonymizationmode=Assignment.ANONYMIZATIONMODE_FULLY_ANONYMOUS))
devilry_group_mommy_factories.feedbackset_first_attempt_published(
group=testgroup, grading_points=3)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testgroup.assignment,
cradmin_instance=self.__mockinstance_with_devilryrole('departmentadmin'),
requestuser=testuser)
self.assertTrue(mockresponse.selector.exists('.devilry-cradmin-groupitemvalue-grade'))
def test_include_groups_with_published_feedback_if_departmentadmin(self):
testuser = mommy.make(settings.AUTH_USER_MODEL)
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup', parentnode=testassignment)
devilry_group_mommy_factories.feedbackset_first_attempt_published(
group=testgroup, grading_points=1),
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testassignment,
cradmin_instance=self.__mockinstance_with_devilryrole('departmentadmin'),
requestuser=testuser)
self.assertEqual(
1,
mockresponse.selector.count('.django-cradmin-listbuilder-itemvalue'))
def test_is_not_waiting_for_feedback(self):
testperiod = mommy.make('core.Period')
testassignment = mommy.make('core.Assignment', parentnode=testperiod)
user = mommy.make(settings.AUTH_USER_MODEL)
relatedstudent = mommy.make('core.RelatedStudent', period=testperiod, user=user)
testgroup = mommy.make('core.AssignmentGroup', parentnode=testassignment)
mommy.make('core.Candidate', assignment_group=testgroup, relatedstudent=relatedstudent)
group_factory.feedbackset_first_attempt_published(group=testgroup, grading_points=10)
# Run collector
collector = PeriodAllResultsCollector(
period=testperiod,
related_student_ids=[relatedstudent.id]
)
self.assertFalse(collector.results[relatedstudent.id].is_waiting_for_feedback(testassignment.id))
def test_get_total_result_only_counts_last_published_feedbackset_is_last_feedbackset(self):
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup', parentnode=testassignment)
user = mommy.make(settings.AUTH_USER_MODEL)
relatedstudent = mommy.make('core.RelatedStudent', period=testassignment.parentnode, user=user)
mommy.make('core.Candidate', assignment_group=testgroup, relatedstudent=relatedstudent)
group_factory.feedbackset_first_attempt_published(group=testgroup, grading_points=10)
group_factory.feedbackset_new_attempt_unpublished(group=testgroup)
# Run collector
collector = PeriodAllResultsCollector(
period=testassignment.parentnode,
related_student_ids=[relatedstudent.id]
)
self.assertEqual(0, collector.results[relatedstudent.id].get_total_result())
def test_anonymizationmode_fully_anonymous_subjectadmin_no_grade(self):
testuser = mommy.make(settings.AUTH_USER_MODEL)
testgroup = mommy.make(
'core.AssignmentGroup',
parentnode=mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start',
anonymizationmode=Assignment.ANONYMIZATIONMODE_FULLY_ANONYMOUS)
)
devilry_group_mommy_factories.feedbackset_first_attempt_published(
group=testgroup, grading_points=3)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testgroup.assignment,
cradmin_instance=self.__mockinstance_with_devilryrole(
'subjectadmin'),
requestuser=testuser)
self.assertFalse(
mockresponse.selector.exists(
'.devilry-cradmin-groupitemvalue-grade'))
def test_querycount_points_to_grade_mapper_custom_table(self):
testuser = mommy.make(settings.AUTH_USER_MODEL, fullname='testuser')
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start',
points_to_grade_mapper=Assignment.
POINTS_TO_GRADE_MAPPER_CUSTOM_TABLE)
point_to_grade_map = mommy.make('core.PointToGradeMap',
assignment=testassignment,
invalid=False)
mommy.make('core.PointRangeToGrade',
point_to_grade_map=point_to_grade_map,
minimum_points=0,
maximum_points=10,
grade='Bad')
mommy.make('core.PointRangeToGrade',
point_to_grade_map=point_to_grade_map,
minimum_points=11,
maximum_points=70,
grade='Ok')
mommy.make('core.PointRangeToGrade',
point_to_grade_map=point_to_grade_map,
minimum_points=71,
maximum_points=100,
grade='Best')
for number in range(30):
group = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
mommy.make('core.Examiner',
relatedexaminer__user=testuser,
assignmentgroup=group)
mommy.make(
'core.Candidate',
relatedstudent__user__fullname='candidate{}'.format(number),
assignment_group=group)
devilry_group_mommy_factories.feedbackset_first_attempt_published(
group=group, grading_points=3)
prefetched_assignment = Assignment.objects.prefetch_point_to_grade_map(
).get(id=testassignment.id)
with self.assertNumQueries(11):
self.mock_http200_getrequest_htmls(
cradmin_role=prefetched_assignment,
cradmin_instance=self.__mockinstance_with_devilryrole(
'departmentadmin'),
requestuser=testuser)
def test_get_examiner_first_attempt_published_choice_alert_new_attempt_button(
self):
# Test that new attempt button exists in the choice alert when last feedbackset is published.
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
group_mommy.feedbackset_first_attempt_published(group=testgroup)
examiner = mommy.make('core.Examiner', assignmentgroup=testgroup)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testgroup, requestuser=examiner.relatedexaminer.user)
self.assertTrue(
mockresponse.selector.exists(
'.devilry-group-feedbackfeed-examiner-after-publish-choice-alert-new-attempt-button'
))
button_text = mockresponse.selector \
.one(
'.devilry-group-feedbackfeed-examiner-after-publish-choice-alert-new-attempt-button').alltext_normalized
self.assertEquals('Give new attempt', button_text)
def test_post_first_attempt_published_comment_with_text(self):
testgroup = mommy.make('core.AssignmentGroup',
parentnode__parentnode=mommy.make_recipe('devilry.apps.core.period_active'))
group_mommy.feedbackset_first_attempt_published(group=testgroup)
examiner = mommy.make('core.Examiner', assignmentgroup=testgroup)
self.mock_http302_postrequest(
cradmin_role=testgroup,
requestuser=examiner.relatedexaminer.user,
viewkwargs={'pk': testgroup.id},
requestkwargs={
'data': {
'text': 'This is a comment',
}
})
self.assertEquals(1, group_models.GroupComment.objects.count())
posted_comment = group_models.GroupComment.objects.all()[0]
self.assertEquals(group_models.GroupComment.VISIBILITY_VISIBLE_TO_EXAMINER_AND_ADMINS,
posted_comment.visibility)
self.assertEquals('This is a comment', posted_comment.text)
def test_select_manually_buttons_does_not_render_if_less_than_two_groups(
self):
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start')
testuser = mommy.make(settings.AUTH_USER_MODEL)
testgroup = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
group_mommy.feedbackset_first_attempt_published(group=testgroup)
mommy.make('core.Examiner',
assignmentgroup=testgroup,
relatedexaminer__user=testuser)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_instance=self.__get_mock_instance(testassignment),
cradmin_role=testassignment,
cradmin_app=self.__get_mock_app(user=testuser),
requestuser=testuser)
self.assertFalse(
mockresponse.selector.exists(
'.devilry-deadlinemanagement-select-groups-buttons'))
def test_post_groups_published_raises_error(self):
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start')
testgroup1 = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
testgroup2 = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
group_mommy.feedbackset_first_attempt_published(group=testgroup1)
group_mommy.feedbackset_first_attempt_unpublished(group=testgroup2)
testuser = self._get_admin_user(testassignment.parentnode)
mommy.make('core.Examiner',
assignmentgroup=testgroup1,
relatedexaminer__user=testuser)
mommy.make('core.Examiner',
assignmentgroup=testgroup2,
relatedexaminer__user=testuser)
new_deadline = timezone.now() + timezone.timedelta(days=3)
new_deadline = new_deadline.replace(microsecond=0)
with self.assertRaises(http.Http404):
self.mock_http302_postrequest(
cradmin_role=testassignment,
cradmin_instance=self._get_mock_instance(testassignment),
cradmin_app=self._get_mock_app(user=testuser),
requestuser=testuser,
viewkwargs={
'deadline':
datetimeutils.datetime_to_url_string(
testassignment.first_deadline),
'handle_deadline':
self.handle_deadline
},
requestkwargs={
'data': {
'new_deadline':
isoformat_withseconds(
timezone.localtime(new_deadline)),
'comment_text':
'You have been given a new attempt.',
'selected_items': [testgroup1.id, testgroup2.id]
}
})
self.assertEqual(2, group_models.FeedbackSet.objects.count())
def test_bulk_send_emails(self):
new_deadline = datetime.utcnow()
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start',
long_name='Assignment 1')
testgroup1 = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
testgroup2 = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
testgroup3 = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
test_fb1 = group_mommy.feedbackset_first_attempt_published(
group=testgroup1, grading_points=1, deadline_datetime=new_deadline)
test_fb2 = group_mommy.feedbackset_first_attempt_published(
group=testgroup2, grading_points=1, deadline_datetime=new_deadline)
test_fb3 = group_mommy.feedbackset_first_attempt_published(
group=testgroup3, grading_points=1, deadline_datetime=new_deadline)
student1 = mommy.make('core.Candidate', assignment_group=testgroup1)
mommy.make('devilry_account.UserEmail',
user=student1.relatedstudent.user,
email='*****@*****.**')
student2 = mommy.make('core.Candidate', assignment_group=testgroup2)
mommy.make('devilry_account.UserEmail',
user=student2.relatedstudent.user,
email='*****@*****.**')
student3 = mommy.make('core.Candidate', assignment_group=testgroup3)
mommy.make('devilry_account.UserEmail',
user=student3.relatedstudent.user,
email='*****@*****.**')
deadline_email.bulk_send_deadline_moved_email(
assignment_id=testassignment.id,
feedbackset_id_list=[test_fb1.id, test_fb2.id, test_fb3.id],
domain_url_start='http://www.example.com/')
self.assertEqual(len(mail.outbox), 3)
recipient_list = []
for mail_item in mail.outbox:
self.assertEqual(len(mail_item.recipients()), 1)
recipient_list.append(mail_item.recipients()[0])
self.assertIn('*****@*****.**', recipient_list)
self.assertIn('*****@*****.**', recipient_list)
self.assertIn('*****@*****.**', recipient_list)
def test_get_feedbackfeed_event_delivery_failed(self):
assignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start',
max_points=10,
passing_grade_min_points=5)
testgroup = mommy.make('core.AssignmentGroup', parentnode=assignment)
feedbackset = group_mommy.feedbackset_first_attempt_published(
group=testgroup,
grading_points=0)
mockresponse = self.mock_http200_getrequest_htmls(cradmin_role=feedbackset.group)
self.assertTrue(mockresponse.selector.exists('.devilry-core-grade-failed'))
self.assertFalse(mockresponse.selector.exists('.devilry-core-grade-passed'))
def test_post_copy_with_passing_grade_from_another_examiners_copied(self):
period = mommy.make_recipe('devilry.apps.core.period_active')
other_assignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start', parentnode=period)
group = mommy.make('core.AssignmentGroup', parentnode=other_assignment)
devilry_group_mommy_factories.feedbackset_first_attempt_published(
grading_points=1, group=group)
self.mock_http302_postrequest(
cradmin_role=period,
requestkwargs={
'data': {
'long_name': 'Test assignment',
'short_name': 'testassignment',
'first_deadline': datetimeutils.isoformat_noseconds(ACTIVE_PERIOD_END),
'student_import_option': '{}_passed'.format(other_assignment.id)
}
})
self.assertEqual(Assignment.objects.filter(short_name='testassignment').count(), 1)
created_assignment = Assignment.objects.get(short_name='testassignment')
self.assertEqual(created_assignment.assignmentgroups.count(), 1)
self.assertEqual(Examiner.objects.filter(assignmentgroup__parentnode=created_assignment).count(), 1)
def test_get_result_for_assignment_feedbackset_is_published(self):
testperiod = mommy.make('core.Period')
testassignment = mommy.make('core.Assignment', parentnode=testperiod)
user = mommy.make(settings.AUTH_USER_MODEL)
relatedstudent = mommy.make('core.RelatedStudent',
period=testperiod,
user=user)
testgroup = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
mommy.make('core.Candidate',
assignment_group=testgroup,
relatedstudent=relatedstudent)
group_factory.feedbackset_first_attempt_published(group=testgroup,
grading_points=10)
# Run collector
collector = PeriodAllResultsCollector(
period=testperiod, related_student_ids=[relatedstudent.id])
self.assertEquals(
10, collector.results[relatedstudent.id].get_result_for_assignment(
testassignment.id))
def test_table_results_points_failed(self):
testperiod = mommy.make('core.Period')
testassignment = mommy.make('core.Assignment', parentnode=testperiod)
requestuser = mommy.make(settings.AUTH_USER_MODEL)
relatedstudent = mommy.make('core.RelatedStudent', period=testperiod)
testgroup = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
mommy.make('core.Candidate',
assignment_group=testgroup,
relatedstudent=relatedstudent)
group_factory.feedbackset_first_attempt_published(group=testgroup,
grading_points=0)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testperiod, requestuser=requestuser)
self.assertTrue(
mockresponse.selector.exists(
'.devilry-overview-all-results-result-cell'))
self.assertEqual(
mockresponse.selector.one(
'.devilry-core-grade-full').alltext_normalized, 'failed (0/1)')
def test_search_anonymous_uses_custom_candidate_ids_nomatch_automatic_anonymous_id(
self):
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start',
uses_custom_candidate_ids=True,
anonymizationmode=core_models.Assignment.
ANONYMIZATIONMODE_SEMI_ANONYMOUS)
testgroup1 = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
testgroup2 = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
devilry_group_mommy_factories.feedbackset_first_attempt_published(
group=testgroup1)
devilry_group_mommy_factories.feedbackset_first_attempt_published(
group=testgroup2)
examiner_user = mommy.make(settings.AUTH_USER_MODEL)
mommy.make('core.Examiner',
relatedexaminer__user=examiner_user,
assignmentgroup=testgroup1)
mommy.make('core.Examiner',
relatedexaminer__user=examiner_user,
assignmentgroup=testgroup2)
mommy.make('core.Candidate',
assignment_group=testgroup1,
relatedstudent__user__fullname='TestUser',
relatedstudent__automatic_anonymous_id='MyAnonymousID')
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testassignment,
requestuser=examiner_user,
cradmin_app=self.__get_mock_app(examiner_user),
viewkwargs={
'deadline':
datetimeutils.datetime_to_string(
testassignment.first_deadline),
'filters_string':
'search-MyAnonymousID'
})
self.assertEqual(
0,
mockresponse.selector.count(
'.django-cradmin-multiselect2-itemvalue'))
def test_get_header_date_with_multiple_feedbacksets(self):
# tests that if there are multiple FeedbackSets', the deadline of the last FeedbackSet should be shown.
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
group_mommy.feedbackset_first_attempt_published(group=testgroup)
testfeedbackset = group_mommy.feedbackset_new_attempt_unpublished(
group=testgroup,
deadline_datetime=timezone.now() + timezone.timedelta(days=10))
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testfeedbackset.group)
self.assertTrue(
mockresponse.selector.exists(
'.devilry-group-feedbackfeed-current-deadline-heading'))
self.assertEquals(
mockresponse.selector.one(
'.devilry-group-feedbackfeed-current-deadline-datetime').
alltext_normalized,
formats.date_format(testfeedbackset.deadline_datetime,
'SHORT_DATETIME_FORMAT'))
def test_all_only_one_group_added_to_form_hidden(self):
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
testgroup1 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
group_mommy.feedbackset_first_attempt_unpublished(group=testgroup1)
testgroup2 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
group_mommy.feedbackset_first_attempt_published(group=testgroup2)
testuser = self._get_admin_user(testassignment.parentnode)
mommy.make('core.Examiner', assignmentgroup=testgroup1, relatedexaminer__user=testuser)
mommy.make('core.Examiner', assignmentgroup=testgroup2, relatedexaminer__user=testuser)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testassignment,
cradmin_instance=self._get_mock_instance(testassignment),
cradmin_app=self._get_mock_app(user=testuser),
requestuser=testuser,
viewkwargs={
'deadline': datetimeutils.datetime_to_url_string(testassignment.first_deadline),
'handle_deadline': self.handle_deadline
}
)
self.assertIn('type="hidden"', mockresponse.selector.one('#id_selected_items_0').__str__())
self.assertIn('value="{}"'.format(testgroup1.id), mockresponse.selector.one('#id_selected_items_0').__str__())
def test_post_can_not_delete_groups_with_content_if_not_departmentadmin(self):
testuser = mommy.make(settings.AUTH_USER_MODEL)
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup', parentnode=testassignment)
devilry_group_mommy_factories.feedbackset_first_attempt_published(
group=testgroup, grading_points=1),
self.assertEqual(1, AssignmentGroup.objects.count())
messagesmock = mock.MagicMock()
self.mock_http200_postrequest_htmls(
cradmin_role=testassignment,
messagesmock=messagesmock,
cradmin_instance=self.__mockinstance_with_devilryrole('subjectadmin'),
requestuser=testuser,
requestkwargs={
'data': {'selected_items': [str(testgroup.id)]}
})
self.assertEqual(1, AssignmentGroup.objects.count())
messagesmock.add.assert_called_once_with(
messages.ERROR,
SelectedGroupsForm.invalid_students_selected_message,
'')
def test_get_examiner_new_attempt_published_choice_alert_exists(self):
# Tests that choice alert for giving new attempt or re editing the last shows
# when first feedbackset and new attempt is published.
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
group_mommy.feedbackset_first_attempt_published(group=testgroup)
testfeedbackset_new_attempt = group_mommy.feedbackset_new_attempt_published(
group=testgroup)
examiner = mommy.make('core.Examiner', assignmentgroup=testgroup)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testgroup, requestuser=examiner.relatedexaminer.user)
self.assertEquals(testgroup.cached_data.last_published_feedbackset,
testfeedbackset_new_attempt)
self.assertEquals(testgroup.cached_data.last_feedbackset,
testfeedbackset_new_attempt)
self.assertTrue(
mockresponse.selector.exists(
'.devilry-group-feedbackfeed-examiner-after-publish-choice-alert'
))
def test_raises_404_feedbackset_is_not_last_feedbackset(self):
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
testfeedbackset = group_mommy.feedbackset_first_attempt_published(
group=testgroup)
group_mommy.feedbackset_new_attempt_published(
group=testgroup, deadline_datetime=timezone.now())
with self.assertRaises(Http404):
self.mock_http200_getrequest_htmls(
cradmin_role=testgroup, viewkwargs={'pk': testfeedbackset.id})
def test_warning_some_candidates_does_not_qualify(self):
testassignment1 = mommy.make_recipe(
'devilry.apps.core.assignment_oldperiod_start',
short_name='cool',
passing_grade_min_points=1,
max_points=1,
)
group1 = mommy.make('core.AssignmentGroup', parentnode=testassignment1)
candidate1 = core_mommy.candidate(group=group1, shortname='april', fullname='April Duck')
group_mommy.feedbackset_first_attempt_published(group=group1, grading_points=1)
group2 = mommy.make('core.AssignmentGroup', parentnode=testassignment1)
candidate2 = core_mommy.candidate(group=group2, shortname='donald', fullname='Donald Duck')
group_mommy.feedbackset_first_attempt_published(group=group2, grading_points=1)
testassignment0 = mommy.make_recipe(
'devilry.apps.core.assignment_oldperiod_middle',
short_name='imba',
parentnode__parentnode=testassignment1.parentnode.parentnode,
passing_grade_min_points=1,
max_points=1,
)
group3 = mommy.make('core.AssignmentGroup', parentnode=testassignment0)
candidate3 = core_mommy.candidate(group=group3, shortname='dewey', fullname='Dewey Duck')
group_mommy.feedbackset_first_attempt_published(group=group3, grading_points=1)
testassignment2 = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start',
short_name='cool',
parentnode__parentnode=testassignment1.parentnode.parentnode,
passing_grade_min_points=2,
max_points=3,
)
new_group1 = mommy.make('core.AssignmentGroup', parentnode=testassignment2)
mommy.make('core.Candidate', assignment_group=new_group1, relatedstudent__user=candidate1.relatedstudent.user)
new_group2 = mommy.make('core.AssignmentGroup', parentnode=testassignment2)
mommy.make('core.Candidate', assignment_group=new_group2, relatedstudent__user=candidate2.relatedstudent.user)
new_group3 = mommy.make('core.AssignmentGroup', parentnode=testassignment2)
mommy.make('core.Candidate', assignment_group=new_group3, relatedstudent__user=candidate3.relatedstudent.user)
messagesmock = mock.MagicMock()
self.mock_http302_postrequest(
cradmin_role=testassignment2,
viewkwargs={'period_id': testassignment1.parentnode.id},
messagesmock=messagesmock,
requestkwargs={
'data': {
'candidates': '[{}, {}, {}]'.format(candidate1.id, candidate2.id, candidate3.id)
}
},
cradmin_instance=self.__mockinstance_with_devilryrole('departmentadmin')
)
messagesmock.add.assert_called_once_with(
messages.WARNING,
'Some students does not qualify to pass the assignment.',
''
)
def test_only_distinct_deadlines_listed(self):
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start')
testgroup1 = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
testgroup2 = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
testgroup3 = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
group_mommy.feedbackset_first_attempt_published(group=testgroup1)
group_mommy.feedbackset_first_attempt_published(group=testgroup2)
group_mommy.feedbackset_first_attempt_published(group=testgroup3)
testuser = mommy.make(settings.AUTH_USER_MODEL)
mommy.make('core.Examiner',
assignmentgroup=testgroup1,
relatedexaminer__user=testuser)
mommy.make('core.Examiner',
assignmentgroup=testgroup2,
relatedexaminer__user=testuser)
mommy.make('core.Examiner',
assignmentgroup=testgroup3,
relatedexaminer__user=testuser)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testassignment,
cradmin_app=self.__get_mock_app(user=testuser),
requestuser=testuser)
self.assertTrue(
mockresponse.selector.one(
'.django-cradmin-listbuilder-itemvalue-titledescription'))
self.assertEquals(
'{}'.format(testassignment.first_deadline),
mockresponse.selector.one(
'.django-cradmin-listbuilder-itemvalue-titledescription-title'
).alltext_normalized)
def test_move_deadline_manually_button_not_rendered_if_all_groups_are_corrected(
self):
"""
Test that move deadline manually should not be rendered if all groups have been corrected.
"""
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start')
testuser = mommy.make(settings.AUTH_USER_MODEL)
testgroup1 = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
testgroup2 = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
testgroup3 = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
group_mommy.feedbackset_first_attempt_published(group=testgroup1)
group_mommy.feedbackset_first_attempt_published(group=testgroup2)
group_mommy.feedbackset_first_attempt_published(group=testgroup3)
mommy.make('core.Examiner',
assignmentgroup=testgroup1,
relatedexaminer__user=testuser)
mommy.make('core.Examiner',
assignmentgroup=testgroup2,
relatedexaminer__user=testuser)
mommy.make('core.Examiner',
assignmentgroup=testgroup3,
relatedexaminer__user=testuser)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_instance=self.__get_mock_instance(testassignment),
cradmin_role=testassignment,
cradmin_app=self.__get_mock_app(user=testuser),
requestuser=testuser)
self.assertFalse(
mockresponse.selector.exists(
'.devilry-deadlinemanagement-move-deadline-button-manually-select'
))
def test_post_num_queries(self):
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start',
long_name='Assignment 0')
testgroup1 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
testgroup2 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
testgroup3 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
devilry_group_mommy_factories.feedbackset_first_attempt_published(group=testgroup1)
devilry_group_mommy_factories.feedbackset_first_attempt_published(group=testgroup2)
devilry_group_mommy_factories.feedbackset_first_attempt_published(group=testgroup3)
examiner_user = mommy.make(settings.AUTH_USER_MODEL)
mommy.make('core.Examiner', assignmentgroup=testgroup1,
relatedexaminer__user=examiner_user)
mommy.make('core.Examiner', assignmentgroup=testgroup2,
relatedexaminer__user=examiner_user)
mommy.make('core.Examiner', assignmentgroup=testgroup3,
relatedexaminer__user=examiner_user)
new_deadline = timezone.now() + timezone.timedelta(days=10)
with self.assertNumQueries(15):
self.mock_http302_postrequest(
cradmin_role=testassignment,
requestuser=examiner_user,
requestkwargs={
'data': {
'feedback_comment_text': 'new attempt given',
'new_deadline': new_deadline.strftime('%Y-%m-%d %H:%M'),
'selected_items': [testgroup1.id, testgroup2.id, testgroup3.id]
}
})
def test_post_new_feedbackset_deadlines(self):
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start',
long_name='Assignment 0')
testgroup1 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
testgroup2 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
testgroup3 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
devilry_group_mommy_factories.feedbackset_first_attempt_published(group=testgroup1)
devilry_group_mommy_factories.feedbackset_first_attempt_published(group=testgroup2)
devilry_group_mommy_factories.feedbackset_first_attempt_published(group=testgroup3)
examiner_user = mommy.make(settings.AUTH_USER_MODEL)
mommy.make('core.Examiner', assignmentgroup=testgroup1,
relatedexaminer__user=examiner_user)
mommy.make('core.Examiner', assignmentgroup=testgroup2,
relatedexaminer__user=examiner_user)
mommy.make('core.Examiner', assignmentgroup=testgroup3,
relatedexaminer__user=examiner_user)
new_deadline = timezone.now() + timezone.timedelta(days=10)
self.mock_http302_postrequest(
cradmin_role=testassignment,
requestuser=examiner_user,
requestkwargs={
'data': {
'feedback_comment_text': 'new attempt given',
'new_deadline': new_deadline,
'selected_items': [testgroup1.id, testgroup2.id, testgroup3.id]
}
})
feedbacksets = group_models.FeedbackSet.objects.all()
self.assertEquals(6, feedbacksets.count())
feedbacksets = feedbacksets.filter(feedbackset_type=group_models.FeedbackSet.FEEDBACKSET_TYPE_NEW_ATTEMPT)
self.assertEquals(3, feedbacksets.count())
self.assertIn(new_deadline, [fb.deadline_datetime for fb in feedbacksets])
def test_raises_404_with_one_group_corrected(self):
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start',
long_name='Assignment 0')
testgroup = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
devilry_group_mommy_factories.feedbackset_first_attempt_published(
group=testgroup)
examiner_user = mommy.make(settings.AUTH_USER_MODEL)
mommy.make('core.Examiner',
assignmentgroup=testgroup,
relatedexaminer__user=examiner_user)
with self.assertRaises(http.Http404):
self.mock_http200_getrequest_htmls(
cradmin_role=testassignment,
requestuser=examiner_user,
cradmin_app=self.__get_mock_app(examiner_user),
viewkwargs={
'deadline':
datetimeutils.datetime_to_string(
testassignment.first_deadline)
})
def test_get_total_result_only_counts_last_published_feedbackset_is_last_feedbackset(
self):
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
user = mommy.make(settings.AUTH_USER_MODEL)
relatedstudent = mommy.make('core.RelatedStudent',
period=testassignment.parentnode,
user=user)
mommy.make('core.Candidate',
assignment_group=testgroup,
relatedstudent=relatedstudent)
group_factory.feedbackset_first_attempt_published(group=testgroup,
grading_points=10)
group_factory.feedbackset_new_attempt_unpublished(group=testgroup)
# Run collector
collector = PeriodAllResultsCollector(
period=testassignment.parentnode,
related_student_ids=[relatedstudent.id])
self.assertEquals(
0, collector.results[relatedstudent.id].get_total_result())
def test_get_last_feedbackset(self):
testuser = mommy.make(settings.AUTH_USER_MODEL)
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
now = timezone.now()
group_mommy.feedbackset_first_attempt_published(
group=testgroup,
grading_published_datetime=now - timezone.timedelta(days=10))
testfeedbackset_last = group_mommy.feedbackset_new_attempt_published(
group=testgroup,
deadline_datetime=now - timezone.timedelta(days=9),
grading_published_datetime=now - timezone.timedelta(days=8))
feedbackset_queryset = builder_base.get_feedbackfeed_builder_queryset(
group=testgroup, requestuser=testuser, devilryrole='unused')
timelinebuilder = FeedbackFeedTimelineBuilder(
feedbacksets=feedbackset_queryset, group=testgroup)
timelinebuilder.build()
self.assertEquals(testfeedbackset_last,
timelinebuilder.get_last_feedbackset())
self.assertEquals(2, group_models.FeedbackSet.objects.count())
def test_success_simple(self):
testassignment1 = mommy.make_recipe(
'devilry.apps.core.assignment_oldperiod_start',
short_name='cool',
parentnode__short_name='s16',
parentnode__long_name='spring16',
passing_grade_min_points=1,
max_points=1,
)
group1 = mommy.make('core.AssignmentGroup', parentnode=testassignment1)
candidate1 = core_mommy.candidate(group=group1, shortname='april', fullname='April Duck')
group_mommy.feedbackset_first_attempt_published(group=group1, grading_points=1)
testassignment2 = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start',
short_name='cool',
parentnode__parentnode=testassignment1.parentnode.parentnode,
passing_grade_min_points=2,
max_points=3,
)
group2 = mommy.make('core.AssignmentGroup', parentnode=testassignment2)
mommy.make('core.Candidate', assignment_group=group2, relatedstudent__user=candidate1.relatedstudent.user)
messagesmock = mock.MagicMock()
self.mock_http302_postrequest(
cradmin_role=testassignment2,
viewkwargs={'period_id': testassignment1.parentnode.id},
messagesmock=messagesmock,
requestkwargs={
'data': {
'candidates': '[{}]'.format(candidate1.id)
}
},
cradmin_instance=self.__mockinstance_with_devilryrole('departmentadmin')
)
messagesmock.add.assert_called_once_with(
messages.SUCCESS,
'Success: {} got approved for this assignment.'.format(candidate1.relatedstudent.user.get_displayname()),
''
)
def test_post_new_attempt(self):
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
testgroup1 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
group_mommy.feedbackset_first_attempt_published(group=testgroup1)
testgroup2 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
group_mommy.feedbackset_first_attempt_published(group=testgroup2)
testuser = self._get_admin_user(testassignment.parentnode)
mommy.make('core.Examiner', assignmentgroup=testgroup1, relatedexaminer__user=testuser)
mommy.make('core.Examiner', assignmentgroup=testgroup2, relatedexaminer__user=testuser)
new_deadline = timezone.now() + timezone.timedelta(days=3)
new_deadline = new_deadline.replace(microsecond=0)
self.mock_postrequest(
cradmin_role=testassignment,
cradmin_instance=self._get_mock_instance(testassignment),
cradmin_app=self._get_mock_app(user=testuser),
requestuser=testuser,
viewkwargs={
'deadline': datetimeutils.datetime_to_url_string(testassignment.first_deadline),
'handle_deadline': 'new-attempt'
},
requestkwargs={
'data': {
'new_deadline': isoformat_withseconds(timezone.localtime(new_deadline)),
'comment_text': 'You have been given a new attempt.',
'selected_items': [testgroup1.id, testgroup2.id]
}
}
)
self.assertEquals(4, group_models.FeedbackSet.objects.count())
self.assertEquals(2, group_models.GroupComment.objects.count())
group_comments = group_models.GroupComment.objects.all()
last_feedbackset_group1 = AssignmentGroupCachedData.objects.get(group_id=testgroup1.id).last_feedbackset
last_feedbackset_group2 = AssignmentGroupCachedData.objects.get(group_id=testgroup2.id).last_feedbackset
self.assertEquals(last_feedbackset_group1.deadline_datetime, new_deadline)
self.assertEquals(last_feedbackset_group2.deadline_datetime, new_deadline)
self.assertEqual(last_feedbackset_group1.last_updated_by, testuser)
self.assertEqual(last_feedbackset_group2.last_updated_by, testuser)
self.assertEquals('You have been given a new attempt.', group_comments[0].text)
self.assertEquals('You have been given a new attempt.', group_comments[1].text)
def test_passed_failed_choices(self):
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start',
passing_grade_min_points=1)
testgroup = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
testfeedbackset = group_mommy.feedbackset_first_attempt_published(
group=testgroup, grading_points=0)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testgroup, viewkwargs={'pk': testfeedbackset.id})
input_element = mockresponse.selector.list('option')
self.assertEquals(input_element[0].get('value'), 'Passed')
self.assertEquals(input_element[1].get('value'), 'Failed')
def test_new_attempt_button_rendered_if_deadline_expired_and_feedbackset_is_graded(self):
testuser = mommy.make(settings.AUTH_USER_MODEL)
deadline_datetime = timezone.now() - timezone.timedelta(days=1)
testgroup = mommy.make('core.AssignmentGroup',
parentnode__parentnode=mommy.make_recipe('devilry.apps.core.period_active'))
test_feedbackset = group_mommy.feedbackset_first_attempt_published(
group=testgroup, deadline_datetime=deadline_datetime, grading_published_datetime=deadline_datetime)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=test_feedbackset.group,
requestuser=testuser,
cradmin_instance=self.__mock_cradmin_instance()
)
self.assertTrue(mockresponse.selector.exists('.devilry-group-event__grade-last-new-attempt-button'))
def test_feedbackset_grading_points_results_multiple(self):
testassignment = mommy.make('core.Assignment',
max_points=10,
grading_system_plugin_id=Assignment.
GRADING_SYSTEM_PLUGIN_ID_POINTS)
testgroup = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
first_publish_datetime = timezone.now() - timezone.timedelta(days=10)
test_feedbackset = group_mommy.feedbackset_first_attempt_published(
group=testgroup,
grading_points=0,
grading_published_datetime=first_publish_datetime)
first_update_published_by = test_feedbackset.grading_published_by
self.assertEqual(FeedbackSetGradingUpdateHistory.objects.count(), 0)
testuser1 = mommy.make(settings.AUTH_USER_MODEL)
testuser2 = mommy.make(settings.AUTH_USER_MODEL)
testuser3 = mommy.make(settings.AUTH_USER_MODEL)
test_feedbackset.publish(published_by=testuser1, grading_points=3)
test_feedbackset.publish(published_by=testuser2, grading_points=6)
test_feedbackset.publish(published_by=testuser3, grading_points=10)
self.assertEqual(FeedbackSetGradingUpdateHistory.objects.count(), 3)
grading_history_queryset = FeedbackSetGradingUpdateHistory.objects.order_by(
'updated_datetime')
grading_history1 = grading_history_queryset[0]
grading_history2 = grading_history_queryset[1]
grading_history3 = grading_history_queryset[2]
# Test history entry for the first update
self.assertEqual(grading_history1.feedback_set, test_feedbackset)
self.assertEqual(grading_history1.old_grading_points, 0)
self.assertEqual(grading_history1.old_grading_published_by,
first_update_published_by)
# Test history entry for the second update
self.assertEqual(grading_history2.feedback_set, test_feedbackset)
self.assertEqual(grading_history2.old_grading_points, 3)
self.assertEqual(grading_history2.old_grading_published_by, testuser1)
# Test history entry for the third update
self.assertEqual(grading_history3.feedback_set, test_feedbackset)
self.assertEqual(grading_history3.old_grading_points, 6)
self.assertEqual(grading_history3.old_grading_published_by, testuser2)
# Test final result on the feedbackset
test_feedbackset = FeedbackSet.objects.get(id=test_feedbackset.id)
self.assertEqual(test_feedbackset.grading_points, 10)
self.assertEqual(test_feedbackset.grading_published_by, testuser3)
