def test_get_feedbackset_grading_updated_multiple_events_rendered(self):
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
test_feedbackset = group_mommy.feedbackset_first_attempt_published(
group=testgroup, grading_points=1)
testuser = mommy.make(settings.AUTH_USER_MODEL,
shortname='*****@*****.**',
fullname='Test User')
mommy.make('devilry_group.FeedbackSetGradingUpdateHistory',
feedback_set=test_feedbackset,
old_grading_points=1,
updated_by=testuser)
mommy.make('devilry_group.FeedbackSetGradingUpdateHistory',
feedback_set=test_feedbackset,
old_grading_points=0,
updated_by=testuser)
mommy.make('devilry_group.FeedbackSetGradingUpdateHistory',
feedback_set=test_feedbackset,
old_grading_points=1,
updated_by=testuser)
mommy.make('devilry_group.FeedbackSetGradingUpdateHistory',
feedback_set=test_feedbackset,
old_grading_points=0,
updated_by=testuser)
# We add an unpublished new attempt, because the feedback view for examiners requires that the last feedbackset
# is not published.
group_mommy.feedbackset_new_attempt_unpublished(group=testgroup)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testgroup)
self.assertEqual(
mockresponse.selector.count(
'.devilry-group-event__grading_updated'), 4)
def test_get_project_groups_from_current_assignment_with_new_attempt_is_excluded(self):
testperiod = mommy.make_recipe('devilry.apps.core.period_active')
past_assignment = mommy.make('core.Assignment', parentnode=testperiod)
current_assignment = mommy.make('core.Assignment', parentnode=testperiod)
related_student = mommy.make('core.RelatedStudent', period=testperiod, user__shortname='testuser1')
# Past assignment
past_assignment_group = mommy.make('core.AssignmentGroup', parentnode=past_assignment)
mommy.make('core.Candidate', relatedstudent=related_student,assignment_group=past_assignment_group)
self.__set_grading_points_for_last_feedbackset(cached_data=past_assignment_group.cached_data)
# Current assignment
current_assignment_group = mommy.make('core.AssignmentGroup', parentnode=current_assignment)
devilry_group_mommy_factories.feedbackset_first_attempt_published(
group=current_assignment_group)
devilry_group_mommy_factories.feedbackset_new_attempt_unpublished(
group=current_assignment_group)
mommy.make('core.Candidate', relatedstudent=related_student, assignment_group=current_assignment_group)
self.assertEqual(AssignmentGroup.objects.filter(parentnode=past_assignment).count(), 1)
self.assertEqual(AssignmentGroup.objects.filter(parentnode=current_assignment).count(), 1)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=current_assignment,
cradmin_instance=self.__mockinstance_with_devilryrole(devilryrole='subjectadmin'),
viewkwargs={
'from_assignment_id': past_assignment.id
}
)
self.assertFalse(mockresponse.selector.exists('.django-cradmin-listbuilder-itemvalue'))
self.assertEqual(self.__get_selected_group_ids_to_be_removed(selector=mockresponse.selector), [])
def test_is_waiting_for_deliveries(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=0,
deadline_datetime=timezone.now() + timedelta(days=1),
)
group_factory.feedbackset_new_attempt_unpublished(
group=testgroup,
deadline_datetime=timezone.now() + timedelta(days=4),
)
# Run collector
collector = PeriodAllResultsCollector(
period=testperiod, related_student_ids=[relatedstudent.id])
self.assertTrue(
collector.results[relatedstudent.id].is_waiting_for_deliveries(
testassignment.id))
def test_get_status_not_created_when_new_feedbackset_is_created_after_last_compressed_archive(self):
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
testuser = mommy.make(settings.AUTH_USER_MODEL, is_superuser=True)
testgroup = mommy.make('core.AssignmentGroup', parentnode=testassignment)
testfeedbackset = devilry_group_mommy_factories.feedbackset_first_attempt_published(
group=testgroup, grading_points=1)
mommy.make('devilry_compressionutil.CompressedArchiveMeta', content_object=testassignment,
created_by=testuser,
created_datetime=timezone.now())
testcomment = mommy.make('devilry_group.GroupComment',
feedback_set=testfeedbackset,
user_role='student',
user__shortname='*****@*****.**')
commentfile = mommy.make('devilry_comment.CommentFile', comment=testcomment, filename='testfile.txt')
commentfile.file.save('testfile.txt', ContentFile('testcontent'))
# Create new feedbackset
devilry_group_mommy_factories.feedbackset_new_attempt_unpublished(group=testgroup)
mockresponse = self.mock_getrequest(
cradmin_app=self.__mock_cradmin_app(),
requestuser=testuser,
viewkwargs={
'content_object_id': testassignment.id
})
self.assertEquals(mockresponse.response.content, '{"status": "not-created"}')
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_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_get_status_not_created_when_new_feedbackset_is_created_after_last_compressed_archive(self):
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup', parentnode=testassignment)
testexaminer = mommy.make('core.Examiner', assignmentgroup=testgroup)
testfeedbackset = devilry_group_mommy_factories.feedbackset_first_attempt_published(
group=testgroup, grading_points=1)
mommy.make('devilry_compressionutil.CompressedArchiveMeta', content_object=testassignment,
created_by=testexaminer.relatedexaminer.user,
created_datetime=timezone.now())
testcomment = mommy.make('devilry_group.GroupComment',
feedback_set=testfeedbackset,
user_role='student',
user__shortname='*****@*****.**')
commentfile = mommy.make('devilry_comment.CommentFile', comment=testcomment, filename='testfile.txt')
commentfile.file.save('testfile.txt', ContentFile('testcontent'))
# Create new feedbackset
devilry_group_mommy_factories.feedbackset_new_attempt_unpublished(group=testgroup)
mockresponse = self.mock_getrequest(
cradmin_app=self.__mock_cradmin_app(),
requestuser=testexaminer.relatedexaminer.user,
viewkwargs={
'content_object_id': testassignment.id
})
self.assertEqual(mockresponse.response.content, b'{"status": "not-created"}')
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_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_feedbackset_second_created_deadline_event(self):
assignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
feedbackset = group_mommy.feedbackset_first_attempt_unpublished(
group__parentnode=assignment,
is_last_in_group=None)
group_mommy.feedbackset_new_attempt_unpublished(group=feedbackset.group)
mockresponse = self.mock_http200_getrequest_htmls(cradmin_role=feedbackset.group)
self.assertTrue(mockresponse.selector.exists('.devilry-group-feedbackfeed-event-message-deadline-created'))
def test_get_examiner_new_attempt_feedback_tab_exist_if_last_feedbackset_is_unpublished(self):
testgroup = mommy.make('core.AssignmentGroup')
group_mommy.feedbackset_new_attempt_unpublished(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-feedback-button'))
def test_get_examiner_new_attempt_feedback_tab_exist_if_last_feedbackset_is_unpublished(self):
testgroup = mommy.make('core.AssignmentGroup')
group_mommy.feedbackset_new_attempt_unpublished(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-feedback-button'))
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_post_new_attempt_added_while_lingering(self):
# Tests what happens when user lingers in the view and one of the groups get a
# new attempt in the meantime.
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)
# group 3 receives a new attempt before post
devilry_group_mommy_factories.feedbackset_new_attempt_unpublished(
group=testgroup3)
messagemock = mock.MagicMock()
mockresponse = self.mock_http200_postrequest_htmls(
cradmin_role=testassignment,
requestuser=examiner_user,
cradmin_app=self.__get_mock_app(examiner_user),
viewkwargs={
'deadline':
datetimeutils.datetime_to_string(testassignment.first_deadline)
},
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]
}
},
messagesmock=messagemock)
self.assertEquals(4, group_models.FeedbackSet.objects.count())
self.assertEquals(0, group_models.GroupComment.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_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_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_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.assertEquals(
mockresponse.selector.list('.header-attempt-number')
[0].alltext_normalized, 'Attempt 1')
self.assertEquals(
mockresponse.selector.list('.header-attempt-number')
[1].alltext_normalized, 'Attempt 2')
def test_get_feedbackset_grading_updated_one_event_rendered(self):
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup', parentnode=testassignment)
test_feedbackset = group_mommy.feedbackset_first_attempt_published(group=testgroup, grading_points=1)
testuser = mommy.make(settings.AUTH_USER_MODEL, shortname='*****@*****.**', fullname='Test User')
mommy.make('devilry_group.FeedbackSetGradingUpdateHistory', feedback_set=test_feedbackset, old_grading_points=1,
updated_by=testuser)
# We add an unpublished new attempt, because the feedback view for examiners requires that the last feedbackset
# is not published.
group_mommy.feedbackset_new_attempt_unpublished(group=testgroup)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testgroup
)
self.assertEqual(mockresponse.selector.count('.devilry-group-event__grading_updated'), 1)
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.assertEquals(2, group_models.FeedbackSet.objects.count())
def test_post_comment_always_to_last_feedbackset(self):
assignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start',
grading_system_plugin_id=core_models.Assignment
.GRADING_SYSTEM_PLUGIN_ID_PASSEDFAILED)
group = mommy.make('core.AssignmentGroup', parentnode=assignment)
examiner = mommy.make('core.Examiner',
assignmentgroup=group,
relatedexaminer=mommy.make('core.RelatedExaminer'))
feedbackset_first = group_mommy.feedbackset_first_attempt_published(group=group)
feedbackset_last = group_mommy.feedbackset_new_attempt_unpublished(group=group)
self.mock_http302_postrequest(
cradmin_role=examiner.assignmentgroup,
requestuser=examiner.relatedexaminer.user,
viewkwargs={'pk': group.id},
requestkwargs={
'data': {
'text': 'This is a feedback',
'examiner_add_public_comment': 'unused value',
}
})
comments = group_models.GroupComment.objects.all()
self.assertEqual(len(comments), 1)
self.assertNotEqual(feedbackset_first, comments[0].feedback_set)
self.assertEqual(feedbackset_last, comments[0].feedback_set)
self.assertEqual(2, group_models.FeedbackSet.objects.count())
def test_post_comment_always_to_last_feedbackset(self):
assignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start',
grading_system_plugin_id=core_models.Assignment.
GRADING_SYSTEM_PLUGIN_ID_PASSEDFAILED)
group = mommy.make('core.AssignmentGroup', parentnode=assignment)
examiner = mommy.make(
'core.Examiner',
assignmentgroup=group,
relatedexaminer=mommy.make('core.RelatedExaminer'))
feedbackset_first = group_mommy.feedbackset_first_attempt_published(
group=group)
feedbackset_last = group_mommy.feedbackset_new_attempt_unpublished(
group=group)
self.mock_http302_postrequest(
cradmin_role=examiner.assignmentgroup,
requestuser=examiner.relatedexaminer.user,
viewkwargs={'pk': group.id},
requestkwargs={
'data': {
'text': 'This is a feedback',
'examiner_add_public_comment': 'unused value',
}
})
comments = group_models.GroupComment.objects.all()
self.assertEquals(len(comments), 1)
self.assertNotEquals(feedbackset_first, comments[0].feedback_set)
self.assertEquals(feedbackset_last, comments[0].feedback_set)
self.assertEquals(2, group_models.FeedbackSet.objects.count())
def test_history_feedbackset_new_attempt_deadline_change(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)
new_attempt_deadline = timezone.localtime(timezone.now() +
timezone.timedelta(days=1))
new_attempt_deadline = new_attempt_deadline.replace(microsecond=0)
feedback_set_new_attempt = group_mommy.feedbackset_new_attempt_unpublished(
group=group, deadline_datetime=new_attempt_deadline)
self.assertEqual(
0,
FeedbackSetDeadlineHistory.objects.filter(
feedback_set__group_id=group.id).count())
new_attempt_updated_deadline = new_attempt_deadline + timezone.timedelta(
days=1)
feedback_set_new_attempt.deadline_datetime = new_attempt_updated_deadline
feedback_set_new_attempt.save()
updated_feedback_set = FeedbackSet.objects.get(
id=feedback_set_new_attempt.id)
deadline_history = FeedbackSetDeadlineHistory.objects.get(
feedback_set_id=updated_feedback_set.id)
self.assertIsNotNone(deadline_history.changed_datetime)
self.assertEqual(new_attempt_deadline, deadline_history.deadline_old)
self.assertEqual(new_attempt_updated_deadline,
deadline_history.deadline_new)
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_num_queries(self):
# Must be refactored
# Test that the number of queries performed is manageable
testuser = mommy.make(settings.AUTH_USER_MODEL)
testgroup = mommy.make('core.AssignmentGroup')
testfeedbackset1 = devilry_group_mommy_factories.feedbackset_first_attempt_published(
group=testgroup,
is_last_in_group=None)
testfeedbackset2 = devilry_group_mommy_factories.feedbackset_new_attempt_unpublished(
group=testgroup,
deadline_datetime=timezone.now() + timezone.timedelta(days=3)
)
testcomment = mommy.make('devilry_group.GroupComment', feedback_set=testfeedbackset1)
testcomment1 = mommy.make('devilry_group.GroupComment', feedback_set=testfeedbackset2)
mommy.make('devilry_comment.CommentFile',
comment=testcomment)
mommy.make('devilry_comment.CommentFile',
comment=testcomment)
mommy.make('devilry_comment.CommentFile',
comment=testcomment1)
mommy.make('devilry_comment.CommentFile',
comment=testcomment1)
with self.assertNumQueries(4):
feedbackset_queryset = builder_base.get_feedbackfeed_builder_queryset(testgroup, testuser, 'unused')
sidebarbuilder = FeedbackFeedSidebarBuilder(feedbacksets=feedbackset_queryset)
sidebarbuilder.build()
sidebarbuilder.get_as_list()
def test_feedbackset_numbering(self):
# Test that the numbering of the feedbacksets are in ascending order.
testuser = mommy.make(settings.AUTH_USER_MODEL)
testgroup = mommy.make('core.AssignmentGroup')
devilry_group_mommy_factories.feedbackset_first_attempt_published(
group=testgroup,
is_last_in_group=None)
devilry_group_mommy_factories.feedbackset_new_attempt_unpublished(
group=testgroup,
deadline_datetime=timezone.now() + timezone.timedelta(days=3)
)
feedbackset_queryset = builder_base.get_feedbackfeed_builder_queryset(testgroup, testuser, 'unused')
sidebarbuilder = FeedbackFeedSidebarBuilder(feedbacksets=feedbackset_queryset)
sidebarbuilder.build()
sidebarlist = sidebarbuilder.get_as_list()
# Loop through and check the numbering.
for numbering, feedbackset_dict in enumerate(sidebarlist):
self.assertEquals(numbering+1, feedbackset_dict['feedbackset_num'])
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_is_waiting_for_deliveries(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=0,
deadline_datetime=timezone.now() + timedelta(days=1),
)
group_factory.feedbackset_new_attempt_unpublished(
group=testgroup,
deadline_datetime=timezone.now() + timedelta(days=4),
)
# Run collector
collector = PeriodAllResultsCollector(
period=testperiod,
related_student_ids=[relatedstudent.id]
)
self.assertTrue(collector.results[relatedstudent.id].is_waiting_for_deliveries(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.assertEquals(
0, collector.results[relatedstudent.id].get_total_result())
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_post_publish_feedbackset_drafts_on_last_feedbackset_only(self):
assignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start',
grading_system_plugin_id=core_models.Assignment.
GRADING_SYSTEM_PLUGIN_ID_PASSEDFAILED)
testgroup = mommy.make('core.AssignmentGroup', parentnode=assignment)
feedbackset_first = group_mommy.feedbackset_first_attempt_published(
group=testgroup)
feedbackset_last = group_mommy.feedbackset_new_attempt_unpublished(
group=testgroup,
deadline_datetime=timezone.now() - timezone.timedelta(days=1))
examiner = mommy.make(
'core.Examiner',
assignmentgroup=testgroup,
relatedexaminer=mommy.make('core.RelatedExaminer'))
mommy.make('core.Candidate',
assignment_group=testgroup,
relatedstudent=mommy.make('core.RelatedStudent'))
comment1 = mommy.make('devilry_group.GroupComment',
text='test text 1',
user=examiner.relatedexaminer.user,
user_role='examiner',
part_of_grading=True,
feedback_set=feedbackset_first)
feedback_comment = mommy.make('devilry_group.GroupComment',
text='part of grading',
user=examiner.relatedexaminer.user,
user_role='examiner',
part_of_grading=True,
feedback_set=feedbackset_last)
self.mock_http302_postrequest(
cradmin_role=testgroup,
requestuser=examiner.relatedexaminer.user,
viewkwargs={'pk': testgroup.id},
requestkwargs={
'data': {
'passed': 'Passed',
'text': 'post comment',
'examiner_publish_feedback': 'unused value',
}
})
cached_group = cache_models.AssignmentGroupCachedData.objects.get(
group=testgroup)
feedback_comments = group_models.GroupComment.objects.all()\
.filter(feedback_set_id=cached_group.last_published_feedbackset.id)\
.order_by('published_datetime')
self.assertEqual(2, len(feedback_comments))
self.assertEqual(feedback_comments[0].text, 'part of grading')
self.assertEqual(feedback_comments[1].text, 'post comment')
self.assertEqual(cached_group.last_published_feedbackset,
feedbackset_last)
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, is_last_in_group=None)
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_post_can_not_publish_with_last_feedbackset_deadline_as_none(self):
assignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start',
grading_system_plugin_id=core_models.Assignment
.GRADING_SYSTEM_PLUGIN_ID_PASSEDFAILED)
group = mommy.make('core.AssignmentGroup', parentnode=assignment)
group_mommy.feedbackset_first_attempt_published(group=group, is_last_in_group=None)
group_mommy.feedbackset_new_attempt_unpublished(group=group, deadline_datetime=None)
examiner = mommy.make('core.Examiner',
assignmentgroup=group,
relatedexaminer=mommy.make('core.RelatedExaminer'))
self.mock_http302_postrequest(
cradmin_role=examiner.assignmentgroup,
requestuser=examiner.relatedexaminer.user,
viewkwargs={'pk': group.id},
requestkwargs={
'data': {
'text': 'This is a feedback',
'examiner_publish_feedback': 'unused value',
}
})
feedbacksets = group_models.FeedbackSet.objects.all().order_by('created_datetime')
self.assertEquals(2, len(feedbacksets))
self.assertIsNotNone(feedbacksets[0].grading_published_datetime)
self.assertIsNone(feedbacksets[1].grading_published_datetime)
def test_post_publish_feedbackset_drafts_on_last_feedbackset_only(self):
assignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start',
grading_system_plugin_id=core_models.Assignment.GRADING_SYSTEM_PLUGIN_ID_PASSEDFAILED)
testgroup = mommy.make('core.AssignmentGroup', parentnode=assignment)
feedbackset_first = group_mommy.feedbackset_first_attempt_published(group=testgroup)
feedbackset_last = group_mommy.feedbackset_new_attempt_unpublished(
group=testgroup,
deadline_datetime=timezone.now() - timezone.timedelta(days=1))
examiner = mommy.make('core.Examiner',
assignmentgroup=testgroup,
relatedexaminer=mommy.make('core.RelatedExaminer'))
mommy.make('core.Candidate',
assignment_group=testgroup,
relatedstudent=mommy.make('core.RelatedStudent'))
comment1 = mommy.make('devilry_group.GroupComment',
text='test text 1',
user=examiner.relatedexaminer.user,
user_role='examiner',
part_of_grading=True,
feedback_set=feedbackset_first)
feedback_comment = mommy.make('devilry_group.GroupComment',
text='part of grading',
user=examiner.relatedexaminer.user,
user_role='examiner',
part_of_grading=True,
feedback_set=feedbackset_last)
self.mock_http302_postrequest(
cradmin_role=testgroup,
requestuser=examiner.relatedexaminer.user,
viewkwargs={'pk': testgroup.id},
requestkwargs={
'data': {
'passed': 'Passed',
'text': 'post comment',
'examiner_publish_feedback': 'unused value',
}
})
cached_group = cache_models.AssignmentGroupCachedData.objects.get(group=testgroup)
feedback_comments = group_models.GroupComment.objects.all()\
.filter(feedback_set_id=cached_group.last_published_feedbackset.id)\
.order_by('published_datetime')
self.assertEqual(2, len(feedback_comments))
self.assertEqual(feedback_comments[0].text, 'part of grading')
self.assertEqual(feedback_comments[1].text, 'post comment')
self.assertEqual(cached_group.last_published_feedbackset, feedbackset_last)
def test_get_last_deadline_two_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)
group_mommy.feedbackset_first_attempt_published(group=testgroup)
testfeedbackset_last = group_mommy.feedbackset_new_attempt_unpublished(
group=testgroup, deadline_datetime=timezone.now())
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(2, len(timelinebuilder.feedbacksets))
self.assertEquals(testfeedbackset_last.deadline_datetime,
timelinebuilder.get_last_deadline())
def test_post_publish_feedbackset_drafts_on_last_feedbackset_only(self):
assignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start',
grading_system_plugin_id=core_models.Assignment.GRADING_SYSTEM_PLUGIN_ID_PASSEDFAILED)
group = mommy.make('core.AssignmentGroup', parentnode=assignment)
feedbackset_first = group_mommy.feedbackset_first_attempt_published(is_last_in_group=None, group=group)
feedbackset_last = group_mommy.feedbackset_new_attempt_unpublished(group=group,
deadline_datetime=timezone.now())
examiner = mommy.make('core.Examiner',
assignmentgroup=group,
relatedexaminer=mommy.make('core.RelatedExaminer'))
student = mommy.make('core.Candidate',
assignment_group=group,
relatedstudent=mommy.make('core.RelatedStudent'))
mommy.make('devilry_group.GroupComment',
text='test text 1',
user=examiner.relatedexaminer.user,
user_role='examiner',
part_of_grading=True,
feedback_set=feedbackset_first)
comment2 = mommy.make('devilry_group.GroupComment',
text='test text 2',
user=examiner.relatedexaminer.user,
user_role='examiner',
part_of_grading=True,
feedback_set=feedbackset_last)
self.mock_http302_postrequest(
cradmin_role=student.assignment_group,
requestuser=student.relatedstudent.user,
viewkwargs={'pk': group.id},
requestkwargs={
'data': {
'passed': True,
'text': 'post comment',
'examiner_publish_feedback': 'unused value',
}
})
feedbacksets = group_models.FeedbackSet.objects.all()
feedback_comments = group_models.GroupComment.objects.all().filter(feedback_set=feedbacksets[1])
self.assertEquals(2, len(feedback_comments))
self.assertEquals(feedback_comments[0], comment2)
self.assertEquals(feedback_comments[1].text, 'post comment')
def test_history_feedbackset_new_attempt_deadline_change(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)
new_attempt_deadline = timezone.localtime(timezone.now() + timezone.timedelta(days=1))
new_attempt_deadline = new_attempt_deadline.replace(microsecond=0)
feedback_set_new_attempt = group_mommy.feedbackset_new_attempt_unpublished(
group=group,
deadline_datetime=new_attempt_deadline)
self.assertEqual(0, FeedbackSetDeadlineHistory.objects.filter(feedback_set__group_id=group.id).count())
new_attempt_updated_deadline = new_attempt_deadline + timezone.timedelta(days=1)
feedback_set_new_attempt.deadline_datetime = new_attempt_updated_deadline
feedback_set_new_attempt.save()
updated_feedback_set = FeedbackSet.objects.get(id=feedback_set_new_attempt.id)
deadline_history = FeedbackSetDeadlineHistory.objects.get(feedback_set_id=updated_feedback_set.id)
self.assertIsNotNone(deadline_history.changed_datetime)
self.assertEqual(new_attempt_deadline, deadline_history.deadline_old)
self.assertEqual(new_attempt_updated_deadline, deadline_history.deadline_new)
def test_feedbackset_new_attempt_unpublished(self):
testgroup = mommy.make('core.AssignmentGroup')
testfeedbackset_first = devilry_group_mommy_factories.feedbackset_first_attempt_published(
group=testgroup)
testfeedbackset = devilry_group_mommy_factories.feedbackset_new_attempt_unpublished(
group=testgroup)
self.assertEquals(2, group_models.FeedbackSet.objects.count())
self.assertEquals(testfeedbackset_first.group.id,
testfeedbackset.group.id)
self.assertIsNone(testfeedbackset.grading_published_by)
self.assertIsNone(testfeedbackset.grading_points)
self.assertIsNone(testfeedbackset.grading_published_datetime)
# test caching
group_cache = cache_models.AssignmentGroupCachedData.objects.get(
group=testgroup)
self.assertEquals(group_cache.first_feedbackset, testfeedbackset_first)
self.assertEquals(group_cache.last_feedbackset, testfeedbackset)
self.assertEquals(group_cache.last_published_feedbackset,
testfeedbackset_first)
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_post_new_attempt_unpublished_comment_with_text(self):
testgroup = mommy.make('core.AssignmentGroup')
testfeedbackset = group_mommy.feedbackset_new_attempt_unpublished(
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(2, group_models.FeedbackSet.objects.count())
last_feedbackset = group_models.FeedbackSet.objects.all()[1]
self.assertEquals(last_feedbackset, testfeedbackset)
self.assertEquals(1, group_models.GroupComment.objects.count())
posted_comment = group_models.GroupComment.objects.all()[0]
self.assertEquals(
group_models.GroupComment.VISIBILITY_VISIBLE_TO_EVERYONE,
posted_comment.visibility)
self.assertEquals('This is a comment', posted_comment.text)
def test_post_comment_always_to_last_feedbackset(self):
assignment = mommy.make_recipe(
"devilry.apps.core.assignment_activeperiod_start",
grading_system_plugin_id=core_models.Assignment.GRADING_SYSTEM_PLUGIN_ID_PASSEDFAILED,
)
group = mommy.make("core.AssignmentGroup", parentnode=assignment)
examiner = mommy.make(
"core.Examiner", assignmentgroup=group, relatedexaminer=mommy.make("core.RelatedExaminer")
)
feedbackset_first = group_mommy.feedbackset_first_attempt_published(is_last_in_group=None, group=group)
feedbackset_last = group_mommy.feedbackset_new_attempt_unpublished(group=group)
self.mock_http302_postrequest(
cradmin_role=examiner.assignmentgroup,
requestuser=examiner.relatedexaminer.user,
viewkwargs={"pk": group.id},
requestkwargs={"data": {"text": "This is a feedback", "examiner_add_public_comment": "unused value"}},
)
comments = group_models.GroupComment.objects.all()
self.assertEquals(len(comments), 1)
self.assertNotEquals(feedbackset_first, comments[0].feedback_set)
self.assertEquals(feedbackset_last, comments[0].feedback_set)
def test_get_examiner_new_attempt_unpublished_choice_alert_does_not_exist(
self):
# Test that choice alert for giving a new attempt or re editing the last does NOT show
# when first feedbackset is published, but the new try is unpublished.
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_unpublished(
group=testgroup)
examiner = mommy.make('core.Examiner', assignmentgroup=testgroup)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testgroup, requestuser=examiner.relatedexaminer.user)
self.assertNotEquals(testgroup.cached_data.last_published_feedbackset,
testfeedbackset_new_attempt)
self.assertEquals(testgroup.cached_data.last_feedbackset,
testfeedbackset_new_attempt)
self.assertFalse(
mockresponse.selector.exists(
'.devilry-group-feedbackfeed-examiner-after-publish-choice-alert'
))
def test_no_comments_if_no_files(self):
# Test that the feedbacksets appears, but no comments if there are no files attached.
testuser = mommy.make(settings.AUTH_USER_MODEL)
testgroup = mommy.make('core.AssignmentGroup')
testfeedbackset1 = devilry_group_mommy_factories.feedbackset_first_attempt_published(
group=testgroup,
is_last_in_group=None)
testfeedbackset2 = devilry_group_mommy_factories.feedbackset_new_attempt_unpublished(
group=testgroup,
deadline_datetime=timezone.now() + timezone.timedelta(days=3)
)
mommy.make('devilry_group.GroupComment', feedback_set=testfeedbackset1)
mommy.make('devilry_group.GroupComment', feedback_set=testfeedbackset2)
feedbackset_queryset = builder_base.get_feedbackfeed_builder_queryset(testgroup, testuser, 'unused')
sidebarbuilder = FeedbackFeedSidebarBuilder(feedbacksets=feedbackset_queryset)
sidebarbuilder.build()
sidebarlist = sidebarbuilder.get_as_list()
self.assertEquals(len(sidebarlist), 2)
self.assertEquals(len(sidebarlist[0]['comments']), 0)
self.assertEquals(len(sidebarlist[1]['comments']), 0)
def test_post_new_attempt_unpublished_comment_with_text(self):
testgroup = mommy.make('core.AssignmentGroup',
parentnode__parentnode=mommy.make_recipe('devilry.apps.core.period_active'))
testfeedbackset = group_mommy.feedbackset_new_attempt_unpublished(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.assertEqual(2, group_models.FeedbackSet.objects.count())
last_feedbackset = group_models.FeedbackSet.objects.all()[1]
self.assertEqual(last_feedbackset, testfeedbackset)
self.assertEqual(1, group_models.GroupComment.objects.count())
posted_comment = group_models.GroupComment.objects.all()[0]
self.assertEqual(group_models.GroupComment.VISIBILITY_VISIBLE_TO_EXAMINER_AND_ADMINS,
posted_comment.visibility)
self.assertEqual('This is a comment', posted_comment.text)
