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_table_hard_deadline_results_no_deliveries(self):
testperiod = mommy.make('core.Period')
testassignment = mommy.make(
'core.Assignment',
parentnode=testperiod,
deadline_handling=Assignment.DEADLINEHANDLING_HARD)
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_unpublished(
group=testgroup,
deadline_datetime=timezone.now() - timezone.timedelta(days=1))
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-overview-all-results-result-cell').
alltext_normalized, 'No deliveries')
def test_get_one_group(self):
testassignment1 = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start')
testassignment2 = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start')
testgroup1 = mommy.make('core.AssignmentGroup',
parentnode=testassignment1)
testgroup2 = mommy.make('core.AssignmentGroup',
parentnode=testassignment2)
relatedstudent = mommy.make('core.RelatedStudent')
mommy.make('core.Candidate',
assignment_group=testgroup1,
relatedstudent=relatedstudent)
mommy.make('core.Candidate',
assignment_group=testgroup2,
relatedstudent=relatedstudent)
feedbackset = group_mommy.feedbackset_first_attempt_unpublished(
group=testgroup1)
group_mommy.feedbackset_first_attempt_unpublished(group=testgroup2)
feedbackset_queryset = builder_base.get_feedbackfeed_builder_queryset(
group=testgroup1,
requestuser=relatedstudent.user,
devilryrole='student')
timelinebuilder = FeedbackFeedTimelineBuilder(
feedbacksets=feedbackset_queryset, group=testgroup1)
self.assertEquals(1, len(timelinebuilder.feedbacksets))
self.assertEquals(feedbackset, timelinebuilder.feedbacksets[0])
self.assertEquals(2, group_models.FeedbackSet.objects.count())
def test_period_admin_three_groups_after_deadline(self):
with self.settings(DEVILRY_COMPRESSED_ARCHIVES_DIRECTORY=self.backend_path):
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start',
short_name='learn-python-basics',
first_deadline=timezone.now() - timezone.timedelta(hours=1))
testgroup1 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
testgroup2 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
testgroup3 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
# Period admin
periodpermissiongroup = mommy.make('devilry_account.PeriodPermissionGroup',
period=testassignment.parentnode)
testuser = mommy.make(settings.AUTH_USER_MODEL)
mommy.make('devilry_account.PermissionGroupUser', user=testuser,
permissiongroup=periodpermissiongroup.permissiongroup)
# Create feedbackset for testgroup1 with commentfiles
testfeedbackset_group1 = group_mommy.feedbackset_first_attempt_unpublished(group=testgroup1)
self.__make_comment_file(feedback_set=testfeedbackset_group1, file_name='testfile.txt',
file_content='testcontent group 1')
mommy.make('core.Candidate', assignment_group=testgroup1, relatedstudent__user__shortname='april')
# Create feedbackset for testgroup2 with commentfiles
testfeedbackset_group2 = group_mommy.feedbackset_first_attempt_unpublished(group=testgroup2)
self.__make_comment_file(feedback_set=testfeedbackset_group2, file_name='testfile.txt',
file_content='testcontent group 2')
mommy.make('core.Candidate', assignment_group=testgroup2, relatedstudent__user__shortname='dewey')
# Create feedbackset for testgroup3 with commentfiles
testfeedbackset_group3 = group_mommy.feedbackset_first_attempt_unpublished(group=testgroup3)
self.__make_comment_file(feedback_set=testfeedbackset_group3, file_name='testfile.txt',
file_content='testcontent group 3')
mommy.make('core.Candidate', assignment_group=testgroup3, relatedstudent__user__shortname='huey')
# run actiongroup
self._run_actiongroup(name='batchframework_assignment',
task=tasks.AssignmentCompressAction,
context_object=testassignment,
started_by=testuser)
archive_meta = archivemodels.CompressedArchiveMeta.objects.get(content_object_id=testassignment.id)
zipfileobject = ZipFile(archive_meta.archive_path)
path_to_file_group1 = os.path.join('april',
'deadline-{}'.format(defaultfilters.date(
testfeedbackset_group1.deadline_datetime, 'b.j.Y-H:i')),
'after_deadline_not_part_of_delivery',
'testfile.txt')
path_to_file_group2 = os.path.join('dewey',
'deadline-{}'.format(defaultfilters.date(
testfeedbackset_group2.deadline_datetime, 'b.j.Y-H:i')),
'after_deadline_not_part_of_delivery',
'testfile.txt')
path_to_file_group3 = os.path.join('huey',
'deadline-{}'.format(defaultfilters.date(
testfeedbackset_group3.deadline_datetime, 'b.j.Y-H:i')),
'after_deadline_not_part_of_delivery',
'testfile.txt')
self.assertEqual(b'testcontent group 1', zipfileobject.read(path_to_file_group1))
self.assertEqual(b'testcontent group 2', zipfileobject.read(path_to_file_group2))
self.assertEqual(b'testcontent group 3', zipfileobject.read(path_to_file_group3))
def test_move_deadline_manually_button_rendered_if_at_least_one_group_is_not_corrected(
self):
"""
If at least one group is corrected, the move deadline manually button should be rendered.
"""
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)
group_mommy.feedbackset_first_attempt_unpublished(group=testgroup1)
group_mommy.feedbackset_first_attempt_published(group=testgroup2)
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_instance=self.__get_mock_instance(testassignment),
cradmin_role=testassignment,
cradmin_app=self.__get_mock_app(user=testuser),
requestuser=testuser)
self.assertTrue(
mockresponse.selector.count(
'.devilry-deadlinemanagement-move-deadline-button-manually-select'
), 1)
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_unpublished(group=testgroup1)
testgroup2 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
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)
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_new_attempt_button_not_rendered_if_no_groups_have_been_corrected(
self):
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)
group_mommy.feedbackset_first_attempt_unpublished(group=testgroup1)
group_mommy.feedbackset_first_attempt_unpublished(group=testgroup2)
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_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_manage_deadline_{}_new_attempt_all_link'.format(
datetimeutils.datetime_to_url_string(
testassignment.first_deadline))))
self.assertFalse(
mockresponse.selector.exists(
'#devilry_manage_deadline_{}_new_attempt_select_link'.format(
datetimeutils.datetime_to_url_string(
testassignment.first_deadline))))
def test_three_groups_after_deadline(self):
with self.settings(DEVILRY_COMPRESSED_ARCHIVES_DIRECTORY=self.backend_path):
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start',
short_name='learn-python-basics',
first_deadline=timezone.now() - timezone.timedelta(hours=1))
testgroup1 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
testgroup2 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
testgroup3 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
# Create user as examiner on all groups.
testuser = mommy.make(settings.AUTH_USER_MODEL, shortname='thor', fullname='Thor')
related_examiner = mommy.make('core.RelatedExaminer', user=testuser, period=testassignment.parentnode)
mommy.make('core.Examiner', relatedexaminer=related_examiner, assignmentgroup=testgroup1)
mommy.make('core.Examiner', relatedexaminer=related_examiner, assignmentgroup=testgroup2)
mommy.make('core.Examiner', relatedexaminer=related_examiner, assignmentgroup=testgroup3)
# Create feedbackset for testgroup1 with commentfiles
testfeedbackset_group1 = group_mommy.feedbackset_first_attempt_unpublished(group=testgroup1)
self.__make_comment_file(feedback_set=testfeedbackset_group1, file_name='testfile.txt',
file_content='testcontent group 1')
mommy.make('core.Candidate', assignment_group=testgroup1, relatedstudent__user__shortname='april')
# Create feedbackset for testgroup2 with commentfiles
testfeedbackset_group2 = group_mommy.feedbackset_first_attempt_unpublished(group=testgroup2)
self.__make_comment_file(feedback_set=testfeedbackset_group2, file_name='testfile.txt',
file_content='testcontent group 2')
mommy.make('core.Candidate', assignment_group=testgroup2, relatedstudent__user__shortname='dewey')
# Create feedbackset for testgroup3 with commentfiles
testfeedbackset_group3 = group_mommy.feedbackset_first_attempt_unpublished(group=testgroup3)
self.__make_comment_file(feedback_set=testfeedbackset_group3, file_name='testfile.txt',
file_content='testcontent group 3')
mommy.make('core.Candidate', assignment_group=testgroup3, relatedstudent__user__shortname='huey')
# run actiongroup
self._run_actiongroup(name='batchframework_assignment',
task=tasks.AssignmentCompressAction,
context_object=testassignment,
started_by=testuser)
archive_meta = archivemodels.CompressedArchiveMeta.objects.get(content_object_id=testassignment.id)
zipfileobject = ZipFile(archive_meta.archive_path)
path_to_file_group1 = os.path.join('april',
'deadline-{}'.format(defaultfilters.date(
testfeedbackset_group1.deadline_datetime, 'b.j.Y-H:i')),
'after_deadline_not_part_of_delivery',
'testfile.txt')
path_to_file_group2 = os.path.join('dewey',
'deadline-{}'.format(defaultfilters.date(
testfeedbackset_group2.deadline_datetime, 'b.j.Y-H:i')),
'after_deadline_not_part_of_delivery',
'testfile.txt')
path_to_file_group3 = os.path.join('huey',
'deadline-{}'.format(defaultfilters.date(
testfeedbackset_group3.deadline_datetime, 'b.j.Y-H:i')),
'after_deadline_not_part_of_delivery',
'testfile.txt')
self.assertEqual(b'testcontent group 1', zipfileobject.read(path_to_file_group1))
self.assertEqual(b'testcontent group 2', zipfileobject.read(path_to_file_group2))
self.assertEqual(b'testcontent group 3', zipfileobject.read(path_to_file_group3))
def test_no_comment_files(self):
with self.settings(DEVILRY_COMPRESSED_ARCHIVES_DIRECTORY=self.backend_path):
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start',
short_name='learn-python-basics',
first_deadline=timezone.now() + timezone.timedelta(days=1))
testgroup1 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
testgroup2 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
# Create examiner.
testuser = mommy.make(settings.AUTH_USER_MODEL, shortname='thor', fullname='Thor')
related_examiner = mommy.make('core.RelatedExaminer', user=testuser, period=testassignment.parentnode)
mommy.make('core.Examiner', relatedexaminer=related_examiner, assignmentgroup=testgroup1)
# Add feedbackset with commentfile to the group the examiner has access to.
testfeedbackset1 = group_mommy.feedbackset_first_attempt_unpublished(group=testgroup1)
mommy.make('devilry_group.GroupComment',
feedback_set=testfeedbackset1,
user_role='student')
mommy.make('core.Candidate', assignment_group=testgroup1, relatedstudent__user__shortname='april')
# Add feedbackset with commentfile to the group the examiner does not have access to.
testfeedbackset2 = group_mommy.feedbackset_first_attempt_unpublished(group=testgroup2)
mommy.make('devilry_group.GroupComment',
feedback_set=testfeedbackset2,
user_role='student')
mommy.make('core.Candidate', assignment_group=testgroup2, relatedstudent__user__shortname='dewey')
# run actiongroup
self._run_actiongroup(name='batchframework_assignment',
task=tasks.AssignmentCompressAction,
context_object=testassignment,
started_by=testuser)
self.assertEqual(archivemodels.CompressedArchiveMeta.objects.count(), 0)
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_unpublished(group=testgroup1)
testgroup2 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
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)
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__())
self.assertIn('type="hidden"', mockresponse.selector.one('#id_selected_items_1').__str__())
self.assertIn('value="{}"'.format(testgroup1.id), mockresponse.selector.one('#id_selected_items_0').__str__())
self.assertIn('value="{}"'.format(testgroup2.id), mockresponse.selector.one('#id_selected_items_1').__str__())
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.assertEquals(2, group_models.FeedbackSet.objects.count())
def test_raises_404_with_two_group_one_corrected(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)
devilry_group_mommy_factories.feedbackset_first_attempt_published(
group=testgroup1)
devilry_group_mommy_factories.feedbackset_first_attempt_unpublished(
group=testgroup2)
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)
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_status_not_created_when_new_file_is_added_to_one_of_the_groups(
self):
# Tests that status "not-created" is returned when CompressedArchiveMeta has a deleted_datetime
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start')
testgroup1 = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
testgroup2 = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
# Same relatedexaminer for both groups
relatedexaminer = mommy.make('core.RelatedExaminer')
testexaminer_group1 = mommy.make('core.Examiner',
assignmentgroup=testgroup1,
relatedexaminer=relatedexaminer)
mommy.make('core.Examiner',
assignmentgroup=testgroup2,
relatedexaminer=relatedexaminer)
testfeedbackset_group1 = devilry_group_mommy_factories.feedbackset_first_attempt_unpublished(
group=testgroup1)
testfeedbackset_group2 = devilry_group_mommy_factories.feedbackset_first_attempt_unpublished(
group=testgroup2)
testcomment1 = mommy.make('devilry_group.GroupComment',
feedback_set=testfeedbackset_group1,
user_role='student',
user__shortname='*****@*****.**')
commentfile1 = mommy.make('devilry_comment.CommentFile',
comment=testcomment1,
filename='testfile.txt')
commentfile1.file.save('testfile.txt', ContentFile('testcontent'))
# Register archive with and add new file to testgroup 2
mommy.make(
'devilry_compressionutil.CompressedArchiveMeta',
content_object=testassignment,
created_by=relatedexaminer.user,
created_by_role=CompressedArchiveMeta.CREATED_BY_ROLE_EXAMINER)
# Run actiongroup
self._register_and_run_actiongroup(
actiongroup_name='batchframework_examiner_compress_assignment',
task=tasks.AssignmentCompressAction,
context_object=testassignment,
user=relatedexaminer.user)
testcomment2 = mommy.make('devilry_group.GroupComment',
feedback_set=testfeedbackset_group2,
user_role='student',
user__shortname='*****@*****.**')
commentfile2 = mommy.make('devilry_comment.CommentFile',
comment=testcomment2,
filename='testfile.txt')
commentfile2.file.save('testfile.txt', ContentFile('testcontent'))
mockresponse = self.mock_getrequest(
cradmin_app=self.__mock_cradmin_app(),
requestuser=relatedexaminer.user,
viewkwargs={'content_object_id': testassignment.id})
self.assertEquals(mockresponse.response.content,
'{"status": "not-created"}')
def test_get_status_no_files(self):
testgroup = mommy.make('core.AssignmentGroup')
devilry_group_mommy_factories.feedbackset_first_attempt_unpublished(
group=testgroup)
mockresponse = self.mock_getrequest(
viewkwargs={'content_object_id': testgroup.parentnode.id})
self.assertEquals('{"status": "no-files"}',
mockresponse.response.content)
def test_get_feedbackset_header(self):
testgroup = mommy.make('core.AssignmentGroup')
group_mommy.feedbackset_first_attempt_unpublished(group=testgroup)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testgroup,
)
self.assertTrue(
mockresponse.selector.one('.devilry-group-feedbackfeed-feed__feedbackset-wrapper--header-first-attempt'))
def test_get_feedbackset_header_grading_info_waiting_for_feedback(self):
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup', parentnode=testassignment)
group_mommy.feedbackset_first_attempt_unpublished(group=testgroup)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testgroup,
)
self.assertEqual(mockresponse.selector.one('.header-grading-info').alltext_normalized, 'waiting for feedback')
def test_get_event_without_any_deadlines_expired(self):
# tests that when a feedbackset has been created and no first deadlines given, either on Assignment
# or FeedbackSet, no 'expired event' is rendered
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_end')
group = mommy.make('core.AssignmentGroup', parentnode=testassignment)
group_mommy.feedbackset_first_attempt_unpublished(group=group)
mockresponse = self.mock_http200_getrequest_htmls(cradmin_role=group)
self.assertFalse(mockresponse.selector.exists('.devilry-group-feedbackfeed-event-message-deadline-expired'))
def test_redirect_on_last_feedbackset_unpublished(self):
group = mommy.make('core.AssignmentGroup')
examiner = mommy.make('core.Examiner',
assignmentgroup=group,
relatedexaminer=mommy.make('core.RelatedExaminer'))
group_mommy.feedbackset_first_attempt_unpublished(group=examiner.assignmentgroup)
mockresponse = self.mock_getrequest(cradmin_role=examiner.assignmentgroup)
self.assertEquals(302, mockresponse.response.status_code)
def test_only_groups_examiner_has_access_to(self):
with self.settings(
DEVILRY_COMPRESSED_ARCHIVES_DIRECTORY=self.backend_path):
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start',
short_name='learn-python-basics',
first_deadline=timezone.now() + timezone.timedelta(days=1))
testgroup1 = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
testgroup2 = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
# Create examiner.
testuser = mommy.make(settings.AUTH_USER_MODEL,
shortname='thor',
fullname='Thor')
related_examiner = mommy.make('core.RelatedExaminer',
user=testuser,
period=testassignment.parentnode)
mommy.make('core.Examiner',
relatedexaminer=related_examiner,
assignmentgroup=testgroup1)
# Add feedbackset with commentfile to the group the examiner has access to.
testfeedbackset1 = group_mommy.feedbackset_first_attempt_unpublished(
group=testgroup1)
self.__make_comment_file(feedback_set=testfeedbackset1,
file_name='testfile.txt',
file_content='testcontent')
mommy.make('core.Candidate',
assignment_group=testgroup1,
relatedstudent__user__shortname='april')
# Add feedbackset with commentfile to the group the examiner does not have access to.
testfeedbackset2 = group_mommy.feedbackset_first_attempt_unpublished(
group=testgroup2)
self.__make_comment_file(feedback_set=testfeedbackset2,
file_name='testfile.txt',
file_content='testcontent')
mommy.make('core.Candidate',
assignment_group=testgroup2,
relatedstudent__user__shortname='dewey')
# run actiongroup
self._run_actiongroup(name='batchframework_assignment',
task=tasks.AssignmentCompressAction,
context_object=testassignment,
started_by=testuser)
archive_meta = archivemodels.CompressedArchiveMeta.objects.get(
content_object_id=testassignment.id)
zipfileobject = ZipFile(archive_meta.archive_path)
self.assertEqual(1, len(zipfileobject.namelist()))
self.assertTrue(zipfileobject.namelist()[0].startswith(
'{}'.format('april')))
self.assertFalse(zipfileobject.namelist()[0].startswith(
'{}'.format('dewey')))
def test_get_feedbackset_header(self):
testgroup = mommy.make('core.AssignmentGroup')
group_mommy.feedbackset_first_attempt_unpublished(group=testgroup)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testgroup, )
self.assertTrue(
mockresponse.selector.one(
'.devilry-group-feedbackfeed-feed__feedbackset-wrapper--header-first-attempt'
))
def test_get_status_no_files(self):
testgroup = mommy.make('core.AssignmentGroup')
devilry_group_mommy_factories.feedbackset_first_attempt_unpublished(group=testgroup)
mockresponse = self.mock_getrequest(
viewkwargs={
'content_object_id': testgroup.parentnode.id
}
)
self.assertEqual(b'{"status": "no-files"}', mockresponse.response.content)
def test_no_404_on_last_feedbackset_unpublished(self):
testgroup = mommy.make('core.AssignmentGroup')
examiner = mommy.make('core.Examiner',
assignmentgroup=testgroup,
relatedexaminer=mommy.make('core.RelatedExaminer'))
group_mommy.feedbackset_first_attempt_unpublished(group=testgroup)
mockresponse = self.mock_getrequest(cradmin_role=examiner.assignmentgroup,
requestuser=examiner.relatedexaminer.user)
self.assertEqual(mockresponse.response.status_code, 200)
def test_grade_not_available_unless_corrected(self):
devilry_group_mommy_factories.feedbackset_first_attempt_unpublished()
testgroup = AssignmentGroup.objects.annotate_with_is_corrected_count(
).first()
selector = htmls.S(
groupdetails.GroupDetailsRenderable(
value=testgroup, assignment=testgroup.assignment).render())
self.assertFalse(
selector.exists('.devilry-cradmin-groupitemvalue-grade'))
def test_get_examiner_first_attempt_feedback_tab_exist_if_last_feedbackset_is_unpublished(self):
testgroup = mommy.make('core.AssignmentGroup')
group_mommy.feedbackset_first_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_event_without_feedbackset_deadline_datetime_expired(self):
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_end')
group = mommy.make('core.AssignmentGroup', parentnode=testassignment)
group_mommy.feedbackset_first_attempt_unpublished(group=group)
mockresponse = self.mock_http200_getrequest_htmls(cradmin_role=group)
self.assertFalse(
mockresponse.selector.exists(
'.devilry-group-feedbackfeed-event-message__deadline-expired'))
def test_get_examiner_first_attempt_feedback_tab_exist_if_last_feedbackset_is_unpublished(self):
testgroup = mommy.make('core.AssignmentGroup')
group_mommy.feedbackset_first_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_status_is_waiting_for_feedback(self):
devilry_group_mommy_factories.feedbackset_first_attempt_unpublished(
group__parentnode=mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start'))
testgroup = AssignmentGroup.objects.annotate_with_is_waiting_for_feedback_count().first()
selector = htmls.S(groupdetails.GroupDetailsRenderable(value=testgroup,
assignment=testgroup.assignment).render())
self.assertEqual(
'Status: waiting for feedback',
selector.one('.devilry-cradmin-groupitemvalue-status').alltext_normalized)
self.assertFalse(selector.exists('.devilry-cradmin-groupitemvalue-grade'))
def test_get_feedbackset_header_title(self):
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup', parentnode=testassignment)
group_mommy.feedbackset_first_attempt_unpublished(group=testgroup)
with self.settings(DATETIME_FORMAT='l j F, Y, H:i', USE_L10N=False):
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testgroup,
)
self.assertEqual(mockresponse.selector.one('.header-title').alltext_normalized,
'Deadline: Saturday 15 January, 2000, 23:59')
def test_status_is_waiting_for_feedback(self):
devilry_group_mommy_factories.feedbackset_first_attempt_unpublished(
group__parentnode=mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start'))
testgroup = AssignmentGroup.objects.annotate_with_is_waiting_for_feedback().first()
selector = htmls.S(groupdetails.GroupDetailsRenderable(value=testgroup,
assignment=testgroup.assignment).render())
self.assertEqual(
'Status: waiting for feedback',
selector.one('.devilry-cradmin-groupitemvalue-status').alltext_normalized)
self.assertFalse(selector.exists('.devilry-cradmin-groupitemvalue-grade'))
def test_get_no_group_comment_pk_raises_404(self):
testgroup = mommy.make('core.AssignmentGroup', parentnode__parentnode=self.__make_active_period())
testuser = mommy.make(settings.AUTH_USER_MODEL)
self.__make_examiner_for_user(user=testuser, group=testgroup)
group_mommy.feedbackset_first_attempt_unpublished(group=testgroup)
with self.assertRaises(Http404):
self.mock_http200_getrequest_htmls(
cradmin_role=testgroup,
requestuser=testuser
)
def test_get_no_group_comment_pk_raises_404(self):
testgroup = mommy.make(
'core.AssignmentGroup',
parentnode__parentnode=self.__make_active_period())
testuser = mommy.make(settings.AUTH_USER_MODEL)
self.__make_examiner_for_user(user=testuser, group=testgroup)
group_mommy.feedbackset_first_attempt_unpublished(group=testgroup)
with self.assertRaises(Http404):
self.mock_http200_getrequest_htmls(cradmin_role=testgroup,
requestuser=testuser)
def test_no_404_on_last_feedbackset_unpublished(self):
testgroup = mommy.make('core.AssignmentGroup')
examiner = mommy.make(
'core.Examiner',
assignmentgroup=testgroup,
relatedexaminer=mommy.make('core.RelatedExaminer'))
group_mommy.feedbackset_first_attempt_unpublished(group=testgroup)
mockresponse = self.mock_getrequest(
cradmin_role=examiner.assignmentgroup,
requestuser=examiner.relatedexaminer.user)
self.assertEquals(mockresponse.response.status_code, 200)
def test_get_feedbackset_header_attempt(self):
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
group_mommy.feedbackset_first_attempt_unpublished(group=testgroup)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testgroup, )
self.assertEquals(
mockresponse.selector.one(
'.header-attempt-number').alltext_normalized, 'Attempt 1')
def test_get_event_without_any_deadlines_expired(self):
# tests that when a feedbackset has been created and no first deadlines given, either on Assignment
# or FeedbackSet, no 'expired event' is rendered
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_end')
group = mommy.make('core.AssignmentGroup', parentnode=testassignment)
group_mommy.feedbackset_first_attempt_unpublished(group=group)
mockresponse = self.mock_http200_getrequest_htmls(cradmin_role=group)
self.assertFalse(
mockresponse.selector.exists(
'.devilry-group-feedbackfeed-event-message-deadline-expired'))
def test_get_header_with_assignment_first_deadline_not_expired(self):
# tests that current-deadline-expired does not exist in header when Assignment.first_deadline is set
# with a deadline in the future
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_end')
testgroup = mommy.make('core.AssignmentGroup', parentnode=testassignment)
group_mommy.feedbackset_first_attempt_unpublished(group=testgroup)
mockresponse = self.mock_http200_getrequest_htmls(cradmin_role=testgroup)
self.assertFalse(mockresponse.selector.exists('.devilry-group-feedbackfeed-current-deadline-expired'))
self.assertEquals(
mockresponse.selector.one('.devilry-group-feedbackfeed-current-deadline-datetime').alltext_normalized,
formats.date_format(testassignment.first_deadline, 'SHORT_DATETIME_FORMAT')
)
def test_get_feedbackset_not_published_only_move_deadline_button_shows(self):
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup', parentnode=testassignment)
group_mommy.feedbackset_first_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.assertEqual(
mockresponse.selector.one('.devilry-group-event__grade-move-deadline-button').alltext_normalized,
'Move deadline')
def test_get_feedbackset_not_published_only_move_deadline_button_shows(self):
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup', parentnode=testassignment)
group_mommy.feedbackset_first_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.assertEquals(
mockresponse.selector.one('.devilry-group-event__grade-move-deadline-button').alltext_normalized,
'Move deadline')
def test_get_feedbackset_header_title(self):
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
group_mommy.feedbackset_first_attempt_unpublished(group=testgroup)
with self.settings(DATETIME_FORMAT='l j F, Y, H:i', USE_L10N=False):
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testgroup, )
self.assertEquals(
mockresponse.selector.one('.header-title').alltext_normalized,
'Deadline: Saturday 15 January, 2000, 23:59')
def test_get_feedbackset_deadline_history_fully_anonymous_username_not_rendered(self):
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start',
anonymizationmode=core_models.Assignment.ANONYMIZATIONMODE_FULLY_ANONYMOUS)
testgroup = mommy.make('core.AssignmentGroup', parentnode=testassignment)
group_mommy.feedbackset_first_attempt_unpublished(group=testgroup)
testuser = mommy.make(settings.AUTH_USER_MODEL, shortname='*****@*****.**', fullname='Test User')
mommy.make('devilry_group.FeedbackSetDeadlineHistory', feedback_set=testgroup.cached_data.first_feedbackset,
changed_by=testuser)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testgroup
)
self.assertFalse(
mockresponse.selector.exists('.devilry-group-feedbackfeed-event-message__user_display_name'))
def test_get_feedbackset_header_grading_info_waiting_for_deliveries_for_feedback(
self):
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_middle')
testgroup = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
group_mommy.feedbackset_first_attempt_unpublished(group=testgroup)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testgroup, )
self.assertEquals(
mockresponse.selector.one(
'.header-grading-info').alltext_normalized,
'waiting for deliveries')
def test_no_comment_files(self):
with self.settings(
DEVILRY_COMPRESSED_ARCHIVES_DIRECTORY=self.backend_path):
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start',
short_name='learn-python-basics',
first_deadline=timezone.now() + timezone.timedelta(days=1))
testgroup1 = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
testgroup2 = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
# Create examiner.
testuser = mommy.make(settings.AUTH_USER_MODEL,
shortname='thor',
fullname='Thor')
related_examiner = mommy.make('core.RelatedExaminer',
user=testuser,
period=testassignment.parentnode)
mommy.make('core.Examiner',
relatedexaminer=related_examiner,
assignmentgroup=testgroup1)
# Add feedbackset with commentfile to the group the examiner has access to.
testfeedbackset1 = group_mommy.feedbackset_first_attempt_unpublished(
group=testgroup1)
mommy.make('devilry_group.GroupComment',
feedback_set=testfeedbackset1,
user_role='student')
mommy.make('core.Candidate',
assignment_group=testgroup1,
relatedstudent__user__shortname='april')
# Add feedbackset with commentfile to the group the examiner does not have access to.
testfeedbackset2 = group_mommy.feedbackset_first_attempt_unpublished(
group=testgroup2)
mommy.make('devilry_group.GroupComment',
feedback_set=testfeedbackset2,
user_role='student')
mommy.make('core.Candidate',
assignment_group=testgroup2,
relatedstudent__user__shortname='dewey')
# run actiongroup
self._run_actiongroup(name='batchframework_assignment',
task=tasks.AssignmentCompressAction,
context_object=testassignment,
started_by=testuser)
self.assertEqual(
archivemodels.CompressedArchiveMeta.objects.count(), 0)
def test_all_groups_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_unpublished(group=testgroup2)
testgroup3 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
group_mommy.feedbackset_first_attempt_unpublished(group=testgroup3)
testgroup4 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
group_mommy.feedbackset_first_attempt_unpublished(group=testgroup4)
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)
mommy.make('core.Examiner', assignmentgroup=testgroup3, relatedexaminer__user=testuser)
mommy.make('core.Examiner', assignmentgroup=testgroup4, 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('type="hidden"', mockresponse.selector.one('#id_selected_items_1').__str__())
self.assertIn('type="hidden"', mockresponse.selector.one('#id_selected_items_2').__str__())
self.assertIn('type="hidden"', mockresponse.selector.one('#id_selected_items_3').__str__())
self.assertIn('value="{}"'.format(testgroup1.id), mockresponse.selector.one('#id_selected_items_0').__str__())
self.assertIn('value="{}"'.format(testgroup2.id), mockresponse.selector.one('#id_selected_items_1').__str__())
self.assertIn('value="{}"'.format(testgroup3.id), mockresponse.selector.one('#id_selected_items_2').__str__())
self.assertIn('value="{}"'.format(testgroup4.id), mockresponse.selector.one('#id_selected_items_3').__str__())
def test_is_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_unpublished(group=testgroup, grading_points=10)
# Run collector
collector = PeriodAllResultsCollector(
period=testperiod,
related_student_ids=[relatedstudent.id]
)
self.assertTrue(collector.results[relatedstudent.id].is_waiting_for_feedback(testassignment.id))
def __make_unpublished_group_for_relatedexaminer(
self,
assignment,
relatedexaminer,
feedbackset_deadline_datetime=None):
if feedbackset_deadline_datetime is None:
feedbackset_deadline_datetime = timezone.now()
group = mommy.make('core.AssignmentGroup', parentnode=assignment)
mommy.make('core.Examiner',
relatedexaminer=relatedexaminer,
assignmentgroup=group)
group_mommy.feedbackset_first_attempt_unpublished(
group=group, deadline_datetime=feedbackset_deadline_datetime)
return group
def test_all_groups_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_unpublished(group=testgroup2)
testgroup3 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
group_mommy.feedbackset_first_attempt_unpublished(group=testgroup3)
testgroup4 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
group_mommy.feedbackset_first_attempt_unpublished(group=testgroup4)
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)
mommy.make('core.Examiner', assignmentgroup=testgroup3, relatedexaminer__user=testuser)
mommy.make('core.Examiner', assignmentgroup=testgroup4, 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__().decode('utf-8'))
self.assertIn('type="hidden"', mockresponse.selector.one('#id_selected_items_1').__str__().decode('utf-8'))
self.assertIn('type="hidden"', mockresponse.selector.one('#id_selected_items_2').__str__().decode('utf-8'))
self.assertIn('type="hidden"', mockresponse.selector.one('#id_selected_items_3').__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'))
self.assertIn('value="{}"'.format(testgroup3.id), mockresponse.selector.one('#id_selected_items_2').__str__().decode('utf-8'))
self.assertIn('value="{}"'.format(testgroup4.id), mockresponse.selector.one('#id_selected_items_3').__str__().decode('utf-8'))
def test_get_last_deadline_one_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_unpublished(group=testgroup)
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(1, len(timelinebuilder.feedbacksets))
self.assertEquals(testassignment.first_deadline,
timelinebuilder.get_last_deadline())
def test_get_feedbackset_deadline_history_username_rendered(self):
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup', parentnode=testassignment)
group_mommy.feedbackset_first_attempt_unpublished(group=testgroup)
testuser = mommy.make(settings.AUTH_USER_MODEL, shortname='*****@*****.**', fullname='Test User')
mommy.make('devilry_group.FeedbackSetDeadlineHistory', feedback_set=testgroup.cached_data.first_feedbackset,
changed_by=testuser)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testgroup
)
self.assertEqual(
mockresponse.selector.one('.devilry-group-feedbackfeed-event-message__user_display_name')
.alltext_normalized,
'Test User([email protected])'
)
def test_get_status_not_created_when_new_file_is_added_to_one_of_the_groups(self):
# Tests that status "not-created" is returned when CompressedArchiveMeta has a deleted_datetime
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
testgroup1 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
testgroup2 = mommy.make('core.AssignmentGroup', parentnode=testassignment)
# Same relatedexaminer for both groups
relatedexaminer = mommy.make('core.RelatedExaminer')
testexaminer_group1 = mommy.make('core.Examiner',
assignmentgroup=testgroup1,
relatedexaminer=relatedexaminer)
mommy.make('core.Examiner',
assignmentgroup=testgroup2,
relatedexaminer=relatedexaminer)
testfeedbackset_group1 = devilry_group_mommy_factories.feedbackset_first_attempt_unpublished(group=testgroup1)
testfeedbackset_group2 = devilry_group_mommy_factories.feedbackset_first_attempt_unpublished(group=testgroup2)
testcomment1 = mommy.make('devilry_group.GroupComment',
feedback_set=testfeedbackset_group1,
user_role='student',
user__shortname='*****@*****.**')
commentfile1 = mommy.make('devilry_comment.CommentFile', comment=testcomment1, filename='testfile.txt')
commentfile1.file.save('testfile.txt', ContentFile('testcontent'))
# Register archive with and add new file to testgroup 2
mommy.make('devilry_compressionutil.CompressedArchiveMeta', content_object=testassignment,
created_by=relatedexaminer.user, created_by_role=CompressedArchiveMeta.CREATED_BY_ROLE_EXAMINER)
# Run actiongroup
self._register_and_run_actiongroup(
actiongroup_name='batchframework_examiner_compress_assignment',
task=tasks.AssignmentCompressAction,
context_object=testassignment,
user=relatedexaminer.user
)
testcomment2 = mommy.make('devilry_group.GroupComment',
feedback_set=testfeedbackset_group2,
user_role='student',
user__shortname='*****@*****.**')
commentfile2 = mommy.make('devilry_comment.CommentFile', comment=testcomment2, filename='testfile.txt')
commentfile2.file.save('testfile.txt', ContentFile('testcontent'))
mockresponse = self.mock_getrequest(
cradmin_app=self.__mock_cradmin_app(),
requestuser=relatedexaminer.user,
viewkwargs={
'content_object_id': testassignment.id
})
self.assertEqual(mockresponse.response.content, b'{"status": "not-created"}')
def test_upload_multiple_files_visibility_everyone(self):
# Test the content of CommentFiles after upload.
# Posting comment with visibility visible to everyone
testfeedbackset = group_mommy.feedbackset_first_attempt_unpublished()
testexaminer = mommy.make('core.examiner',
assignmentgroup=testfeedbackset.group)
temporary_filecollection = group_mommy.temporary_file_collection_with_tempfiles(
file_list=[
SimpleUploadedFile(name='testfile1.txt',
content=b'Test content1',
content_type='text/txt'),
SimpleUploadedFile(name='testfile2.txt',
content=b'Test content2',
content_type='text/txt'),
SimpleUploadedFile(name='testfile3.txt',
content=b'Test content3',
content_type='text/txt')
],
user=testexaminer.relatedexaminer.user)
self.mock_http302_postrequest(
cradmin_role=testexaminer.assignmentgroup,
requestuser=testexaminer.relatedexaminer.user,
viewkwargs={'pk': testfeedbackset.group.id},
requestkwargs={
'data': {
'text': '',
'temporary_file_collection_id': temporary_filecollection.id
}
})
self.assertEquals(1, group_models.GroupComment.objects.count())
self.assertEqual(
group_models.GroupComment.VISIBILITY_VISIBLE_TO_EVERYONE,
group_models.GroupComment.objects.all()[0].visibility)
self.assertEquals(3, comment_models.CommentFile.objects.count())
def test_grouplist_comments_sanity(self):
testuser = mommy.make(settings.AUTH_USER_MODEL)
testgroup = mommy.make('core.AssignmentGroup',
parentnode=mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start'))
mommy.make('core.Candidate',
relatedstudent__user=testuser,
assignment_group=testgroup)
feedbackset = devilry_group_mommy_factories.feedbackset_first_attempt_unpublished(
group=testgroup)
mommy.make('devilry_group.GroupComment',
feedback_set=feedbackset,
visibility=GroupComment.VISIBILITY_VISIBLE_TO_EVERYONE,
user_role=Comment.USER_ROLE_STUDENT,
_quantity=2)
mommy.make('devilry_comment.CommentFile',
comment=mommy.make('devilry_group.GroupComment',
feedback_set=feedbackset,
visibility=GroupComment.VISIBILITY_VISIBLE_TO_EVERYONE,
user_role=Comment.USER_ROLE_STUDENT))
mommy.make('devilry_group.GroupComment',
feedback_set=feedbackset,
visibility=GroupComment.VISIBILITY_VISIBLE_TO_EVERYONE,
user_role=Comment.USER_ROLE_EXAMINER,
_quantity=5)
mommy.make('devilry_group.GroupComment', # Should not be part of count
feedback_set=feedbackset,
visibility=GroupComment.VISIBILITY_VISIBLE_TO_EXAMINER_AND_ADMINS,
user_role=Comment.USER_ROLE_EXAMINER)
mockresponse = self.mock_http200_getrequest_htmls(
requestuser=testuser)
self.assertEqual(
'3 comments from student. 1 file from student. 5 comments from examiner.',
mockresponse.selector.one(
'.devilry-cradmin-groupitemvalue '
'.devilry-cradmin-groupitemvalue-comments').alltext_normalized)
def test_get_status_finished_with_link_to_downloadurl(self):
# When the BatchOperation task is complete, it creates a CompressedArchiveMeta entry in
# the database. This is simulated by NOT creating a BatchOperation, but just creating a CompressedArchive
# instead. This is the first thing that gets checked in API.
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_unpublished(group=testgroup)
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'))
mommy.make('devilry_compressionutil.CompressedArchiveMeta', content_object=testassignment,
created_by=testexaminer.relatedexaminer.user,
created_by_role=CompressedArchiveMeta.CREATED_BY_ROLE_EXAMINER)
mock_cradmin_app = mock.MagicMock()
mock_cradmin_app.reverse_appurl.return_value = 'url-to-downloadview'
mockresponse = self.mock_getrequest(
cradmin_app=mock_cradmin_app,
requestuser=testexaminer.relatedexaminer.user,
viewkwargs={
'content_object_id': testassignment.id
})
self.assertEqual(mockresponse.response.content,
b'{"status": "finished", "download_link": "url-to-downloadview"}')
def test_post_compressed_archive_is_saved_as_examiner(self):
# Tests that status "not-created" is returned when CompressedArchiveMeta has a deleted_datetime
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup', parentnode=testassignment)
relatedexaminer = mommy.make('core.RelatedExaminer')
testexaminer = mommy.make('core.Examiner', assignmentgroup=testgroup, relatedexaminer=relatedexaminer)
testfeedbackset_group = devilry_group_mommy_factories.feedbackset_first_attempt_unpublished(group=testgroup)
testcomment1 = mommy.make('devilry_group.GroupComment',
feedback_set=testfeedbackset_group,
user_role='student',
user__shortname='*****@*****.**')
commentfile1 = mommy.make('devilry_comment.CommentFile', comment=testcomment1, filename='testfile.txt')
commentfile1.file.save('testfile.txt', ContentFile('testcontent'))
# Run actiongroup
self._register_and_run_actiongroup(
actiongroup_name='batchframework_examiner_compress_assignment',
task=tasks.AssignmentCompressAction,
context_object=testassignment,
user=relatedexaminer.user
)
mock_cradmin_app = mock.MagicMock()
mock_cradmin_app.reverse_appurl.return_value = 'url-to-downloadview'
self.mock_postrequest(
cradmin_app=mock_cradmin_app,
requestuser=testexaminer.relatedexaminer.user,
viewkwargs={
'content_object_id': testassignment.id
})
self.assertEqual(CompressedArchiveMeta.objects.count(), 1)
archive_meta = CompressedArchiveMeta.objects.get()
self.assertEqual(archive_meta.created_by_role, CompressedArchiveMeta.CREATED_BY_ROLE_EXAMINER)
self.assertTrue(
archive_meta.archive_path.startswith('devilry_testfiles/devilry_compressed_archives/examiner/'))
def test_upload_single_file_content_visibility_examiners_and_admins(self):
# Test the content of a CommentFile after upload.
# Posting comment with visibility visible to examiners and admins
testfeedbackset = group_mommy.feedbackset_first_attempt_unpublished()
testexaminer = mommy.make('core.examiner',
assignmentgroup=testfeedbackset.group)
temporary_filecollection = group_mommy.temporary_file_collection_with_tempfiles(
file_list=[
SimpleUploadedFile(name='testfile.txt',
content=b'Test content',
content_type='text/txt')
],
user=testexaminer.relatedexaminer.user)
self.mock_http302_postrequest(
cradmin_role=testexaminer.assignmentgroup,
requestuser=testexaminer.relatedexaminer.user,
viewkwargs={'pk': testfeedbackset.group.id},
requestkwargs={
'data': {
'text': '',
'temporary_file_collection_id': temporary_filecollection.id
}
})
self.assertEquals(1, group_models.GroupComment.objects.count())
self.assertEqual(
group_models.GroupComment.
VISIBILITY_VISIBLE_TO_EXAMINER_AND_ADMINS,
group_models.GroupComment.objects.all()[0].visibility)
self.assertEquals(1, comment_models.CommentFile.objects.count())
comment_file = comment_models.CommentFile.objects.all()[0]
self.assertEqual('testfile.txt', comment_file.filename)
self.assertEqual('Test content', comment_file.file.file.read())
self.assertEqual(len('Test content'), comment_file.filesize)
self.assertEqual('text/txt', comment_file.mimetype)
def test_post_initial_empty_comment_can_be_edited(self):
testgroup = mommy.make('core.AssignmentGroup', parentnode__parentnode=self.__make_active_period())
testuser = mommy.make(settings.AUTH_USER_MODEL)
self.__make_examiner_for_user(user=testuser, group=testgroup)
testfeedbackset = group_mommy.feedbackset_first_attempt_unpublished(group=testgroup)
groupcomment = mommy.make('devilry_group.GroupComment',
user=testuser,
user_role='examiner',
feedback_set=testfeedbackset)
messagesmock = mock.MagicMock()
self.mock_http302_postrequest(
cradmin_role=testgroup,
requestuser=testuser,
viewkwargs={'pk': groupcomment.id},
requestkwargs={
'data': {
'text': 'edited'
}
},
messagesmock=messagesmock)
db_comment = group_models.GroupComment.objects.get(id=groupcomment.id)
edit_history = group_models.GroupCommentEditHistory.objects.get()
self.assertEqual(group_models.GroupCommentEditHistory.objects.count(), 1)
self.assertEqual('edited', db_comment.text)
self.assertEqual('', edit_history.pre_edit_text)
self.assertEqual('edited', edit_history.post_edit_text)
messagesmock.add.assert_called_once_with(messages.SUCCESS, 'Comment updated!', '')
def test_feedbackset_publish_published_by_is_none(self):
grading_points = 10
test_feedbackset = group_mommy.feedbackset_first_attempt_unpublished(
group__parentnode__first_deadline=timezone.now() - timezone.timedelta(days=1))
with self.assertRaisesMessage(ValidationError,
'A FeedbackSet can not be published without being published by someone.'):
test_feedbackset.publish(published_by=None, grading_points=grading_points)
def test_post_comment_private_history_visibility(self):
testgroup = mommy.make('core.AssignmentGroup', parentnode__parentnode=self.__make_active_period())
testuser = mommy.make(settings.AUTH_USER_MODEL)
self.__make_examiner_for_user(user=testuser, group=testgroup)
testfeedbackset = group_mommy.feedbackset_first_attempt_unpublished(group=testgroup)
groupcomment = mommy.make('devilry_group.GroupComment',
user=testuser,
user_role='examiner',
text='unedited',
part_of_grading=True,
visibility=group_models.GroupComment.VISIBILITY_PRIVATE,
feedback_set=testfeedbackset)
messagesmock = mock.MagicMock()
self.mock_http302_postrequest(
cradmin_role=testgroup,
requestuser=testuser,
viewkwargs={'pk': groupcomment.id},
requestkwargs={
'data': {
'text': 'edited'
}
},
messagesmock=messagesmock)
edit_history_entry = group_models.GroupCommentEditHistory.objects.get()
self.assertEqual(edit_history_entry.visibility, group_models.GroupComment.VISIBILITY_PRIVATE)
def test_feedbackset_publish_grading_points_is_none(self):
testuser = mommy.make(settings.AUTH_USER_MODEL)
test_feedbackset = group_mommy.feedbackset_first_attempt_unpublished(
group__parentnode__first_deadline=timezone.now() - timezone.timedelta(days=1))
with self.assertRaisesMessage(ValidationError,
'A FeedbackSet can not be published without providing "points".'):
test_feedbackset.publish(published_by=testuser, grading_points=None)
def test_feedback_set_publish_multiple_feedbackcomments_order(self):
examiner = mommy.make('core.Examiner')
testfeedbackset = group_mommy.feedbackset_first_attempt_unpublished(
group__parentnode__parentnode=mommy.make_recipe('devilry.apps.core.period_active')
)
mommy.make('devilry_group.GroupComment',
user_role='examiner',
user=examiner.relatedexaminer.user,
feedback_set=testfeedbackset,
part_of_grading=True,
visibility=group_models.GroupComment.VISIBILITY_PRIVATE,
text='comment1')
mommy.make('devilry_group.GroupComment',
user_role='examiner',
user=examiner.relatedexaminer.user,
feedback_set=testfeedbackset,
part_of_grading=True,
visibility=group_models.GroupComment.VISIBILITY_PRIVATE,
text='comment2')
mommy.make('devilry_group.GroupComment',
user_role='examiner',
user=examiner.relatedexaminer.user,
feedback_set=testfeedbackset,
part_of_grading=True,
visibility=group_models.GroupComment.VISIBILITY_PRIVATE,
text='comment3')
testfeedbackset.publish(published_by=examiner.relatedexaminer.user, grading_points=1)
groupcomments = group_models.GroupComment.objects.\
filter(feedback_set__id=testfeedbackset.id).\
order_by('published_datetime')
self.assertEqual(groupcomments[0].text, 'comment1')
self.assertEqual(groupcomments[1].text, 'comment2')
self.assertEqual(groupcomments[2].text, 'comment3')
def test_upload_multiple_files_contents_visibility_examiners_and_admins(
self):
# Test the content of a CommentFile after upload.
testfeedbackset = group_mommy.feedbackset_first_attempt_unpublished()
testexaminer = mommy.make('core.examiner',
assignmentgroup=testfeedbackset.group)
temporary_filecollection = group_mommy.temporary_file_collection_with_tempfiles(
file_list=[
SimpleUploadedFile(name='testfile1.txt',
content=b'Test content1',
content_type='text/txt'),
SimpleUploadedFile(name='testfile2.txt',
content=b'Test content2',
content_type='text/txt'),
SimpleUploadedFile(name='testfile3.txt',
content=b'Test content3',
content_type='text/txt')
],
user=testexaminer.relatedexaminer.user)
self.mock_http302_postrequest(
cradmin_role=testexaminer.assignmentgroup,
requestuser=testexaminer.relatedexaminer.user,
viewkwargs={'pk': testfeedbackset.group.id},
requestkwargs={
'data': {
'text': '',
'examiner_add_comment_for_examiners': 'unused value',
'temporary_file_collection_id': temporary_filecollection.id
}
})
self.assertEquals(1, group_models.GroupComment.objects.count())
self.assertEqual(
group_models.GroupComment.
VISIBILITY_VISIBLE_TO_EXAMINER_AND_ADMINS,
group_models.GroupComment.objects.all()[0].visibility)
self.assertEquals(3, comment_models.CommentFile.objects.count())
comment_file1 = comment_models.CommentFile.objects.get(
filename='testfile1.txt')
comment_file2 = comment_models.CommentFile.objects.get(
filename='testfile2.txt')
comment_file3 = comment_models.CommentFile.objects.get(
filename='testfile3.txt')
# Check content of testfile 1.
self.assertEqual('testfile1.txt', comment_file1.filename)
self.assertEqual('Test content1', comment_file1.file.file.read())
self.assertEqual(len('Test content1'), comment_file1.filesize)
self.assertEqual('text/txt', comment_file1.mimetype)
# Check content of testfile 2.
self.assertEqual('testfile2.txt', comment_file2.filename)
self.assertEqual('Test content2', comment_file2.file.file.read())
self.assertEqual(len('Test content2'), comment_file2.filesize)
self.assertEqual('text/txt', comment_file2.mimetype)
# Check content of testfile 3.
self.assertEqual('testfile3.txt', comment_file3.filename)
self.assertEqual('Test content3', comment_file3.file.file.read())
self.assertEqual(len('Test content3'), comment_file3.filesize)
self.assertEqual('text/txt', comment_file3.mimetype)
def test_post_initial_empty_comment_can_be_edited(self):
testuser = mommy.make('devilry_account.User', shortname='admin', fullname='Thor')
testperiod = mommy.make_recipe('devilry.apps.core.period_active', admins=[testuser])
testgroup = mommy.make('core.AssignmentGroup', parentnode__parentnode=testperiod)
testfeedbackset = group_mommy.feedbackset_first_attempt_unpublished(group=testgroup)
groupcomment = mommy.make('devilry_group.GroupComment',
user=testuser,
user_role=group_models.GroupComment.USER_ROLE_ADMIN,
published_datetime=timezone.now(),
feedback_set=testfeedbackset)
messagesmock = mock.MagicMock()
self.mock_http302_postrequest(
cradmin_role=testgroup,
requestuser=testuser,
viewkwargs={'pk': groupcomment.id},
messagesmock=messagesmock,
requestkwargs={
'data': {
'text': 'edited'
}
})
db_comment = group_models.GroupComment.objects.get(id=groupcomment.id)
edit_history = group_models.GroupCommentEditHistory.objects.get()
self.assertEqual(group_models.GroupCommentEditHistory.objects.count(), 1)
self.assertEqual('edited', db_comment.text)
self.assertEqual('', edit_history.pre_edit_text)
self.assertEqual('edited', edit_history.post_edit_text)
messagesmock.add.assert_called_once_with(messages.SUCCESS, 'Comment updated!', '')
