def test_grouplist_status_corrected_show_grade_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_published(
group=testgroup, grading_points=2)
mockresponse = self.mock_http200_getrequest_htmls(
requestuser=testuser, cradmin_role=testperiod)
self.assertFalse(
mockresponse.selector.exists(
'.devilry-cradmin-groupitemvalue '
'.devilry-cradmin-groupitemvalue-status'))
self.assertEqual(
'Grade: passed',
mockresponse.selector.one(
'.devilry-cradmin-groupitemvalue '
'.devilry-cradmin-groupitemvalue-grade').alltext_normalized)
def test_is_not_waiting_for_deliveries_if_last_published_feedbackset_is_last_feedbackset(
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_published(
group=testgroup,
grading_points=10,
deadline_datetime=timezone.now() + timedelta(days=4),
)
# Run collector
collector = PeriodAllResultsCollector(
period=testperiod, related_student_ids=[relatedstudent.id])
self.assertFalse(
collector.results[relatedstudent.id].is_waiting_for_deliveries(
testassignment.id))
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_published(
group__parentnode=assignment,
is_last_in_group=None)
group_mommy.feedbackset_new_attempt_published(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_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_get_examiner_new_attempt_feedback_tab_does_not_exist_if_last_feedbackset_is_published(self):
testgroup = mommy.make('core.AssignmentGroup')
group_mommy.feedbackset_new_attempt_published(
group=testgroup,
deadline_datetime=timezone.now() + timedelta(days=3))
examiner = mommy.make('core.Examiner', assignmentgroup=testgroup)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testgroup,
requestuser=examiner.relatedexaminer.user
)
self.assertFalse(mockresponse.selector.exists('.devilry-group-feedbackfeed-feedback-button'))
def test_raises_404_feedbackset_is_not_last_feedbackset(self):
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup', parentnode=testassignment)
testfeedbackset = group_mommy.feedbackset_first_attempt_published(group=testgroup)
group_mommy.feedbackset_new_attempt_published(group=testgroup, deadline_datetime=timezone.now())
with self.assertRaises(Http404):
self.mock_http200_getrequest_htmls(
cradmin_role=testgroup,
viewkwargs={
'pk': testfeedbackset.id
})
def test_get_examiner_new_attempt_feedback_tab_does_not_exist_if_last_feedbackset_is_published(self):
testgroup = mommy.make('core.AssignmentGroup')
group_mommy.feedbackset_new_attempt_published(
group=testgroup,
deadline_datetime=timezone.now() + timedelta(days=3))
examiner = mommy.make('core.Examiner', assignmentgroup=testgroup)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testgroup,
requestuser=examiner.relatedexaminer.user
)
self.assertFalse(mockresponse.selector.exists('.devilry-group-feedbackfeed-feedback-button'))
def test_raises_404_feedbackset_is_not_last_feedbackset(self):
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
testfeedbackset = group_mommy.feedbackset_first_attempt_published(
group=testgroup)
group_mommy.feedbackset_new_attempt_published(
group=testgroup, deadline_datetime=timezone.now())
with self.assertRaises(Http404):
self.mock_http200_getrequest_htmls(
cradmin_role=testgroup, viewkwargs={'pk': testfeedbackset.id})
def test_post_feedback_updates_score_last_feedbackset_is_not_first_feedbackset(
self):
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
first_feedbackset_publishing_datetime = timezone.now(
) - timezone.timedelta(days=2)
last_feedbackset_publishing_datetime = timezone.now(
) - timezone.timedelta(days=1)
group_mommy.feedbackset_first_attempt_published(
group=testgroup,
grading_points=1,
grading_published_datetime=first_feedbackset_publishing_datetime)
group_mommy.feedbackset_new_attempt_published(
group=testgroup,
grading_points=0,
grading_published_datetime=last_feedbackset_publishing_datetime)
testuser = mommy.make(settings.AUTH_USER_MODEL)
# Test that the first feedbackset is not changed for sanity!
first_feedbackset = testgroup.cached_data.first_feedbackset
self.assertEqual(first_feedbackset.grading_points, 1)
self.assertNotEqual(first_feedbackset.grading_published_by, testuser)
self.assertEqual(first_feedbackset.grading_published_datetime,
first_feedbackset_publishing_datetime)
# Test the last feedbackset before bulk feedback.
last_feedbackset = testgroup.cached_data.last_feedbackset
self.assertEqual(last_feedbackset.grading_points, 0)
self.assertNotEqual(last_feedbackset.grading_published_by, testuser)
self.assertEqual(last_feedbackset.grading_published_datetime,
last_feedbackset_publishing_datetime)
self.mock_http302_postrequest(
cradmin_role=testassignment,
cradmin_instance=self.__mock_crinstance(),
requestuser=testuser,
requestkwargs={
'data': {
'feedback_comment_text': 'feedback comment',
'selected_items': [testgroup.id]
}
})
feedbackset = FeedbackSet.objects.get(id=last_feedbackset.id)
self.assertEqual(feedbackset.grading_points, testassignment.max_points)
self.assertEqual(feedbackset.grading_published_by, testuser)
self.assertTrue(feedbackset.grading_published_datetime >
last_feedbackset_publishing_datetime)
def test_get_num_elements_in_timeline(self):
testuser = mommy.make(settings.AUTH_USER_MODEL)
assignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
group = mommy.make('core.AssignmentGroup', parentnode=assignment)
now = timezone.now()
group_mommy.feedbackset_first_attempt_published(
group=group,
is_last_in_group=None,
created_datetime=now - timezone.timedelta(days=20),
grading_published_datetime=now-timezone.timedelta(days=19))
group_mommy.feedbackset_new_attempt_published(
group=group,
is_last_in_group=None,
created_datetime=now - timezone.timedelta(days=18),
deadline_datetime=now-timezone.timedelta(days=17),
grading_published_datetime=now-timezone.timedelta(days=16))
group_mommy.feedbackset_new_attempt_published(
group=group,
is_last_in_group=None,
created_datetime=now - timezone.timedelta(days=15),
deadline_datetime=now-timezone.timedelta(days=14),
grading_published_datetime=now-timezone.timedelta(days=13))
group_mommy.feedbackset_new_attempt_published(
group=group,
created_datetime=now - timezone.timedelta(days=12),
deadline_datetime=now-timezone.timedelta(days=11),
grading_published_datetime=now-timezone.timedelta(days=10))
timelinebuilder = FeedbackFeedTimelineBuilder(group=group, requestuser=testuser, devilryrole='unused')
timelinebuilder.build()
self.assertEquals(11, len(timelinebuilder.timeline))
def test_get_num_elements_in_timeline(self):
testuser = mommy.make(settings.AUTH_USER_MODEL)
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
now = timezone.now()
group_mommy.feedbackset_first_attempt_published(
group=testgroup,
created_datetime=now - timezone.timedelta(days=20),
grading_published_datetime=now - timezone.timedelta(days=19))
group_mommy.feedbackset_new_attempt_published(
group=testgroup,
created_datetime=now - timezone.timedelta(days=18),
deadline_datetime=now - timezone.timedelta(days=17),
grading_published_datetime=now - timezone.timedelta(days=16))
group_mommy.feedbackset_new_attempt_published(
group=testgroup,
created_datetime=now - timezone.timedelta(days=15),
deadline_datetime=now - timezone.timedelta(days=14),
grading_published_datetime=now - timezone.timedelta(days=13))
group_mommy.feedbackset_new_attempt_published(
group=testgroup,
created_datetime=now - timezone.timedelta(days=12),
deadline_datetime=now - timezone.timedelta(days=11),
grading_published_datetime=now - timezone.timedelta(days=10))
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(11, len(timelinebuilder.timeline))
self.assertEquals(4, group_models.FeedbackSet.objects.count())
def test_grouplist_status_corrected_show_grade_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)
devilry_group_mommy_factories.feedbackset_first_attempt_published(
group=testgroup, grading_points=3, is_last_in_group=False)
devilry_group_mommy_factories.feedbackset_new_attempt_published(
group=testgroup, is_last_in_group=True, grading_points=2)
mockresponse = self.mock_http200_getrequest_htmls(
requestuser=testuser)
self.assertFalse(
mockresponse.selector.exists(
'.devilry-cradmin-groupitemvalue '
'.devilry-cradmin-groupitemvalue-status'))
self.assertEqual(
'Grade: passed',
mockresponse.selector.one(
'.devilry-cradmin-groupitemvalue '
'.devilry-cradmin-groupitemvalue-grade').alltext_normalized)
def test_is_not_waiting_for_deliveries_if_last_published_feedbackset_is_last_feedbackset(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_published(
group=testgroup,
grading_points=10,
deadline_datetime=timezone.now() + timedelta(days=4),
)
# Run collector
collector = PeriodAllResultsCollector(
period=testperiod,
related_student_ids=[relatedstudent.id]
)
self.assertFalse(collector.results[relatedstudent.id].is_waiting_for_deliveries(testassignment.id))
def test_get_last_deadline(self):
testuser = mommy.make(settings.AUTH_USER_MODEL)
assignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
group = mommy.make('core.AssignmentGroup', parentnode=assignment)
now = timezone.now()
group_mommy.feedbackset_first_attempt_published(
group=group,
is_last_in_group=None,
grading_published_datetime=now-timezone.timedelta(days=10))
feedbackset_last = group_mommy.feedbackset_new_attempt_published(
group=group,
deadline_datetime=now-timezone.timedelta(days=9),
# is_last_in_group=None,
grading_published_datetime=now-timezone.timedelta(days=8))
timelinebuilder = FeedbackFeedTimelineBuilder(group=group, requestuser=testuser, devilryrole='unused')
timelinebuilder.build()
self.assertEquals(feedbackset_last.deadline_datetime, timelinebuilder.get_last_deadline())
def setUp(self):
AssignmentGroupDbCacheCustomSql().initialize()
testuser = mommy.make(settings.AUTH_USER_MODEL)
self.assignment = mommy.make_recipe(
'devilry.apps.core.assignment_oldperiod_start',
short_name='cool',
long_name='imba',
parentnode__short_name='s15',
parentnode__long_name='spring 15',
passing_grade_min_points=10,
max_points=15)
group1 = mommy.make('core.AssignmentGroup',
parentnode=self.assignment,
name='group1')
self.previous_feedbackset = group_mommy.feedbackset_new_attempt_published(
group=group1, grading_points=11)
candidate1 = core_mommy.candidate(group=group1,
fullname='Mr. Pomeroy',
shortname='mrpomeroy')
current_assignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start',
short_name='cool',
passing_grade_min_points=7,
max_points=10)
current_group = mommy.make('core.AssignmentGroup',
parentnode=current_assignment,
name='current_group1')
mommy.make('core.Candidate',
assignment_group=current_group,
relatedstudent__user=candidate1.relatedstudent.user)
self.passed_in_previous = PassedInPreviousPeriod(
current_assignment, self.assignment.parentnode)
candidate_queryset = self.passed_in_previous.get_queryset()
self.assertEqual(1, candidate_queryset.count())
self.passed_in_previous.set_passed_in_current_period(
candidate_queryset, testuser)
self.published_feedbackset = AssignmentGroup.objects.get(id=current_group.id) \
.cached_data.last_published_feedbackset
self.feedbackset_passed_previous = FeedbacksetPassedPreviousPeriod.objects.filter(
feedbackset=self.published_feedbackset).first()
def test_feedbackset_new_attempt_published_without_grading_datetime(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_published(
group=testgroup,
deadline_datetime=timezone.now() + timezone.timedelta(days=3))
self.assertEquals(2, group_models.FeedbackSet.objects.count())
self.assertEquals(testfeedbackset_first.group.id,
testfeedbackset.group.id)
self.assertIsNotNone(testfeedbackset.grading_published_by)
self.assertIsNotNone(testfeedbackset.grading_points)
self.assertIsNotNone(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)
def test_post_new_attempt_published_comment_with_text(self):
testgroup = mommy.make('core.AssignmentGroup')
testfeedbackset = group_mommy.feedbackset_new_attempt_published(
group=testgroup)
examiner = mommy.make('core.Examiner', assignmentgroup=testgroup)
self.mock_http302_postrequest(
cradmin_role=testgroup,
requestuser=examiner.relatedexaminer.user,
viewkwargs={'pk': testgroup.id},
requestkwargs={'data': {
'text': 'This is a comment',
}})
self.assertEquals(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_get_examiner_new_attempt_published_choice_alert_exists(self):
# Tests that choice alert for giving new attempt or re editing the last shows
# when first feedbackset and new attempt is published.
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
group_mommy.feedbackset_first_attempt_published(group=testgroup)
testfeedbackset_new_attempt = group_mommy.feedbackset_new_attempt_published(
group=testgroup)
examiner = mommy.make('core.Examiner', assignmentgroup=testgroup)
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=testgroup, requestuser=examiner.relatedexaminer.user)
self.assertEquals(testgroup.cached_data.last_published_feedbackset,
testfeedbackset_new_attempt)
self.assertEquals(testgroup.cached_data.last_feedbackset,
testfeedbackset_new_attempt)
self.assertTrue(
mockresponse.selector.exists(
'.devilry-group-feedbackfeed-examiner-after-publish-choice-alert'
))
def test_get_last_feedbackset(self):
testuser = mommy.make(settings.AUTH_USER_MODEL)
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
now = timezone.now()
group_mommy.feedbackset_first_attempt_published(
group=testgroup,
grading_published_datetime=now - timezone.timedelta(days=10))
testfeedbackset_last = group_mommy.feedbackset_new_attempt_published(
group=testgroup,
deadline_datetime=now - timezone.timedelta(days=9),
grading_published_datetime=now - timezone.timedelta(days=8))
feedbackset_queryset = builder_base.get_feedbackfeed_builder_queryset(
group=testgroup, requestuser=testuser, devilryrole='unused')
timelinebuilder = FeedbackFeedTimelineBuilder(
feedbacksets=feedbackset_queryset, group=testgroup)
timelinebuilder.build()
self.assertEquals(testfeedbackset_last,
timelinebuilder.get_last_feedbackset())
self.assertEquals(2, group_models.FeedbackSet.objects.count())
def test_post_new_attempt_published_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_published(group=testgroup)
examiner = mommy.make('core.Examiner', assignmentgroup=testgroup)
self.mock_http302_postrequest(
cradmin_role=testgroup,
requestuser=examiner.relatedexaminer.user,
viewkwargs={'pk': testgroup.id},
requestkwargs={
'data': {
'text': 'This is a comment',
}
})
self.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)
def test_listbuilder_sidebar_complete_example(self):
# Just a sanity check with a full example comprising of two FeedbackSets
# with one GroupComment each and one CommentFile for each GroupComment.
testuser = mommy.make(settings.AUTH_USER_MODEL)
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup', parentnode=testassignment)
candidate = mommy.make('core.Candidate',
assignment_group=testgroup,
relatedstudent__user__fullname='Test User1',
relatedstudent__user__shortname='*****@*****.**')
examiner = mommy.make('core.Examiner',
assignmentgroup=testgroup,
relatedexaminer_user__fullname='Test User2',
relatedexaminer__user__shortname='*****@*****.**')
testfeedbackset1 = group_mommy.feedbackset_first_attempt_published(
grading_published_datetime=(testassignment.first_deadline + timezone.timedelta(days=1)),
grading_points=10,
created_by=examiner.relatedexaminer.user,
created_datetime=(testassignment.publishing_time),
is_last_in_group=None,
group=testgroup,
grading_published_by=examiner.relatedexaminer.user)
testcomment1 = mommy.make('devilry_group.GroupComment',
created_datetime=testfeedbackset1.current_deadline() - timezone.timedelta(hours=1),
published_datetime=testfeedbackset1.current_deadline() - timezone.timedelta(hours=1),
user=candidate.relatedstudent.user,
user_role='student',
feedback_set=testfeedbackset1)
commentfile1 = mommy.make('devilry_comment.CommentFile', comment=testcomment1, filename='testfile1.txt')
commentfile1.file.save('testfile1.txt', ContentFile(''))
mommy.make('devilry_group.GroupComment',
created_datetime=testfeedbackset1.current_deadline() + timezone.timedelta(hours=1),
published_datetime=testfeedbackset1.current_deadline() + timezone.timedelta(hours=1),
user=examiner.relatedexaminer.user,
user_role='examiner',
part_of_grading=True,
feedback_set=testfeedbackset1)
testfeedbackset2 = group_mommy.feedbackset_new_attempt_published(
grading_published_datetime=testfeedbackset1.grading_published_datetime + timezone.timedelta(days=4),
grading_points=10,
created_by=examiner.relatedexaminer.user,
created_datetime=testfeedbackset1.grading_published_datetime + timezone.timedelta(hours=10),
deadline_datetime=testfeedbackset1.grading_published_datetime + timezone.timedelta(days=3),
group=testgroup,
grading_published_by=examiner.relatedexaminer.user)
testcomment2 = mommy.make('devilry_group.GroupComment',
created_datetime=testfeedbackset2.current_deadline() - timezone.timedelta(hours=1),
published_datetime=testfeedbackset2.current_deadline() - timezone.timedelta(hours=1),
user=candidate.relatedstudent.user,
user_role='student',
feedback_set=testfeedbackset2)
commentfile1 = mommy.make('devilry_comment.CommentFile', comment=testcomment2, filename='testfile2.txt')
commentfile1.file.save('testfile2.txt', ContentFile(''))
mommy.make('devilry_group.GroupComment',
created_datetime=testfeedbackset2.current_deadline() + timezone.timedelta(hours=1),
published_datetime=testfeedbackset2.current_deadline() + timezone.timedelta(hours=1),
user=examiner.relatedexaminer.user,
user_role='examiner',
part_of_grading=True,
feedback_set=testfeedbackset2)
feedbackset_queryset = builder_base.get_feedbackfeed_builder_queryset(
group=testgroup,
requestuser=testuser,
devilryrole='student'
)
built_sidebar = feedbackfeed_sidebarbuilder.FeedbackFeedSidebarBuilder(
feedbacksets=feedbackset_queryset,
)
built_sidebar.build()
listbuilder_list = feedbackfeed_sidebar.SidebarListBuilderList.from_built_sidebar(
built_sidebar=built_sidebar,
group=testgroup,
devilryrole='student',
assignment=testassignment
)
# Checks the structure of the built list:
#
# FeedbackSetItemValue
# GroupCommentListBuilderList
# GroupCommentItemValue
# FileListBuilderList
# FileItemValue
# FeedbackSetItemValue
# GroupCommentListBuilderList
# GroupCommentItemValue
# FileListBuilderList
# FileItemValue
#
self.assertTrue(isinstance(listbuilder_list.renderable_list[0],
feedbackfeed_sidebar.FeedbackSetItemValue))
self.assertTrue(isinstance(listbuilder_list.renderable_list[1],
feedbackfeed_sidebar.GroupCommentListBuilderList))
self.assertTrue(isinstance(listbuilder_list.renderable_list[1].renderable_list[0],
feedbackfeed_sidebar.GroupCommentItemValue))
self.assertTrue(isinstance(listbuilder_list.renderable_list[1].renderable_list[1],
feedbackfeed_sidebar.FileListBuilderList))
self.assertTrue(isinstance(listbuilder_list.renderable_list[1].renderable_list[1].renderable_list[0],
feedbackfeed_sidebar.FileItemValue))
self.assertTrue(isinstance(listbuilder_list.renderable_list[2],
feedbackfeed_sidebar.FeedbackSetItemValue))
self.assertTrue(isinstance(listbuilder_list.renderable_list[3],
feedbackfeed_sidebar.GroupCommentListBuilderList))
self.assertTrue(isinstance(listbuilder_list.renderable_list[3].renderable_list[0],
feedbackfeed_sidebar.GroupCommentItemValue))
self.assertTrue(isinstance(listbuilder_list.renderable_list[3].renderable_list[1],
feedbackfeed_sidebar.FileListBuilderList))
self.assertTrue(isinstance(listbuilder_list.renderable_list[3].renderable_list[1].renderable_list[0],
feedbackfeed_sidebar.FileItemValue))
def test_listbuilder_list_items_complete_example(self):
"""
Test a complete example of the listbuilder with all events.
"""
testuser = mommy.make(settings.AUTH_USER_MODEL)
testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup', parentnode=testassignment)
candidate = mommy.make('core.Candidate',
assignment_group=testgroup,
relatedstudent__user__fullname='Test User1',
relatedstudent__user__shortname='*****@*****.**')
examiner = mommy.make('core.Examiner',
assignmentgroup=testgroup,
relatedexaminer_user__fullname='Test User2',
relatedexaminer__user__shortname='*****@*****.**')
testfeedbackset1 = group_mommy.feedbackset_first_attempt_published(
grading_published_datetime=(testassignment.first_deadline + timezone.timedelta(days=1)),
grading_points=10,
created_by=examiner.relatedexaminer.user,
created_datetime=(testassignment.publishing_time),
is_last_in_group=None,
group=testgroup,
grading_published_by=examiner.relatedexaminer.user)
mommy.make('devilry_group.GroupComment',
created_datetime=testfeedbackset1.current_deadline() - timezone.timedelta(hours=1),
published_datetime=testfeedbackset1.current_deadline() - timezone.timedelta(hours=1),
user=candidate.relatedstudent.user,
user_role='student',
feedback_set=testfeedbackset1)
mommy.make('devilry_group.GroupComment',
created_datetime=testfeedbackset1.current_deadline() + timezone.timedelta(hours=1),
published_datetime=testfeedbackset1.current_deadline() + timezone.timedelta(hours=1),
user=examiner.relatedexaminer.user,
user_role='examiner',
part_of_grading=True,
feedback_set=testfeedbackset1)
testfeedbackset2 = group_mommy.feedbackset_new_attempt_published(
grading_published_datetime=testfeedbackset1.grading_published_datetime + timezone.timedelta(days=4),
grading_points=10,
created_by=examiner.relatedexaminer.user,
created_datetime=testfeedbackset1.grading_published_datetime + timezone.timedelta(hours=10),
deadline_datetime=testfeedbackset1.grading_published_datetime + timezone.timedelta(days=3),
group=testgroup,
grading_published_by=examiner.relatedexaminer.user)
mommy.make('devilry_group.GroupComment',
created_datetime=testfeedbackset2.current_deadline() - timezone.timedelta(hours=1),
published_datetime=testfeedbackset2.current_deadline() - timezone.timedelta(hours=1),
user=candidate.relatedstudent.user,
user_role='student',
feedback_set=testfeedbackset2)
mommy.make('devilry_group.GroupComment',
created_datetime=testfeedbackset2.current_deadline() + timezone.timedelta(hours=1),
published_datetime=testfeedbackset2.current_deadline() + timezone.timedelta(hours=1),
user=examiner.relatedexaminer.user,
user_role='examiner',
part_of_grading=True,
feedback_set=testfeedbackset2)
feedbackset_queryset = builder_base.get_feedbackfeed_builder_queryset(
group=testgroup,
requestuser=testuser,
devilryrole='student'
)
built_timeline = feedbackfeed_timelinebuilder.FeedbackFeedTimelineBuilder(
feedbacksets=feedbackset_queryset,
group=testgroup
)
built_timeline.build()
listbuilder_list = listbuilder.TimelineListBuilderList.from_built_timeline(
built_timeline,
group=testgroup,
devilryrole='student',
assignment=testassignment
)
self.assertTrue(isinstance(listbuilder_list.renderable_list[0], listbuilder.StudentGroupCommentItemValue))
self.assertTrue(isinstance(listbuilder_list.renderable_list[1], listbuilder.DeadlineExpiredItemValue))
self.assertTrue(isinstance(listbuilder_list.renderable_list[2], listbuilder.ExaminerGroupCommentItemValue))
self.assertTrue(isinstance(listbuilder_list.renderable_list[3], listbuilder.GradeItemValue))
self.assertTrue(isinstance(listbuilder_list.renderable_list[4], listbuilder.DeadlineCreatedItemValue))
self.assertTrue(isinstance(listbuilder_list.renderable_list[5], listbuilder.StudentGroupCommentItemValue))
self.assertTrue(isinstance(listbuilder_list.renderable_list[6], listbuilder.DeadlineExpiredItemValue))
self.assertTrue(isinstance(listbuilder_list.renderable_list[7], listbuilder.ExaminerGroupCommentItemValue))
self.assertTrue(isinstance(listbuilder_list.renderable_list[8], listbuilder.GradeItemValue))
def test_complete_timeline_events_example(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)
testcandidate = mommy.make(
'core.Candidate',
assignment_group=testgroup,
relatedstudent__user__fullname='Test User1',
relatedstudent__user__shortname='*****@*****.**')
testexaminer = mommy.make(
'core.Examiner',
assignmentgroup=testgroup,
relatedexaminer_user__fullname='Test User2',
relatedexaminer__user__shortname='*****@*****.**')
# First feedbackset published with comments and grading
testfeedbackset1 = group_mommy.feedbackset_first_attempt_published(
grading_published_datetime=testassignment.first_deadline +
timezone.timedelta(days=1),
grading_points=10,
created_by=testexaminer.relatedexaminer.user,
created_datetime=testassignment.publishing_time,
group=testgroup,
grading_published_by=testexaminer.relatedexaminer.user)
mommy.make('devilry_group.GroupComment',
created_datetime=testfeedbackset1.current_deadline() -
timezone.timedelta(hours=1),
published_datetime=testfeedbackset1.current_deadline() -
timezone.timedelta(hours=1),
user=testcandidate.relatedstudent.user,
user_role='student',
feedback_set=testfeedbackset1)
mommy.make('devilry_group.GroupComment',
created_datetime=testfeedbackset1.current_deadline() +
timezone.timedelta(hours=1),
published_datetime=testfeedbackset1.current_deadline() +
timezone.timedelta(hours=1),
user=testexaminer.relatedexaminer.user,
user_role='examiner',
part_of_grading=True,
feedback_set=testfeedbackset1)
# Second feedbackset with comments and grading
testfeedbackset2 = group_mommy.feedbackset_new_attempt_published(
grading_published_datetime=testfeedbackset1.
grading_published_datetime + timezone.timedelta(days=4),
grading_points=10,
created_datetime=testfeedbackset1.grading_published_datetime +
timezone.timedelta(hours=10),
deadline_datetime=testfeedbackset1.grading_published_datetime +
timezone.timedelta(days=3),
created_by=testexaminer.relatedexaminer.user,
group=testgroup,
grading_published_by=testexaminer.relatedexaminer.user)
mommy.make('devilry_group.GroupComment',
created_datetime=testfeedbackset2.current_deadline() -
timezone.timedelta(hours=1),
published_datetime=testfeedbackset2.current_deadline() -
timezone.timedelta(hours=1),
user=testcandidate.relatedstudent.user,
user_role='student',
feedback_set=testfeedbackset2)
mommy.make('devilry_group.GroupComment',
created_datetime=testfeedbackset2.current_deadline() +
timezone.timedelta(hours=1),
published_datetime=testfeedbackset2.current_deadline() +
timezone.timedelta(hours=1),
user=testexaminer.relatedexaminer.user,
user_role='examiner',
part_of_grading=True,
feedback_set=testfeedbackset2)
feedbackset_queryset = builder_base.get_feedbackfeed_builder_queryset(
group=testgroup, requestuser=testuser, devilryrole='student')
built_timeline = FeedbackFeedTimelineBuilder(
feedbacksets=feedbackset_queryset, group=testgroup)
built_timeline.build()
builder_list = built_timeline.get_as_list()
self.assertEquals(builder_list[0]['type'], 'comment')
self.assertEquals(builder_list[1]['type'], 'deadline_expired')
self.assertEquals(builder_list[2]['type'], 'comment')
self.assertEquals(builder_list[3]['type'], 'grade')
self.assertEquals(builder_list[4]['type'], 'deadline_created')
self.assertEquals(builder_list[5]['type'], 'comment')
self.assertEquals(builder_list[6]['type'], 'deadline_expired')
self.assertEquals(builder_list[7]['type'], 'comment')
self.assertEquals(builder_list[8]['type'], 'grade')
self.assertEquals(2, group_models.FeedbackSet.objects.count())
def test_listbuilder_list_items_complete_example(self):
"""
Test a complete example of the listbuilder with all events.
"""
testuser = mommy.make(settings.AUTH_USER_MODEL)
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start')
testgroup = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
candidate = mommy.make(
'core.Candidate',
assignment_group=testgroup,
relatedstudent__user__fullname='Test User1',
relatedstudent__user__shortname='*****@*****.**')
examiner = mommy.make(
'core.Examiner',
assignmentgroup=testgroup,
relatedexaminer_user__fullname='Test User2',
relatedexaminer__user__shortname='*****@*****.**')
testfeedbackset1 = group_mommy.feedbackset_first_attempt_published(
grading_published_datetime=(testassignment.first_deadline +
timezone.timedelta(days=1)),
grading_points=10,
created_by=examiner.relatedexaminer.user,
created_datetime=(testassignment.publishing_time),
is_last_in_group=None,
group=testgroup,
grading_published_by=examiner.relatedexaminer.user)
mommy.make('devilry_group.GroupComment',
created_datetime=testfeedbackset1.current_deadline() -
timezone.timedelta(hours=1),
published_datetime=testfeedbackset1.current_deadline() -
timezone.timedelta(hours=1),
user=candidate.relatedstudent.user,
user_role='student',
feedback_set=testfeedbackset1)
mommy.make('devilry_group.GroupComment',
created_datetime=testfeedbackset1.current_deadline() +
timezone.timedelta(hours=1),
published_datetime=testfeedbackset1.current_deadline() +
timezone.timedelta(hours=1),
user=examiner.relatedexaminer.user,
user_role='examiner',
part_of_grading=True,
feedback_set=testfeedbackset1)
testfeedbackset2 = group_mommy.feedbackset_new_attempt_published(
grading_published_datetime=testfeedbackset1.
grading_published_datetime + timezone.timedelta(days=4),
grading_points=10,
created_by=examiner.relatedexaminer.user,
created_datetime=testfeedbackset1.grading_published_datetime +
timezone.timedelta(hours=10),
deadline_datetime=testfeedbackset1.grading_published_datetime +
timezone.timedelta(days=3),
group=testgroup,
grading_published_by=examiner.relatedexaminer.user)
mommy.make('devilry_group.GroupComment',
created_datetime=testfeedbackset2.current_deadline() -
timezone.timedelta(hours=1),
published_datetime=testfeedbackset2.current_deadline() -
timezone.timedelta(hours=1),
user=candidate.relatedstudent.user,
user_role='student',
feedback_set=testfeedbackset2)
mommy.make('devilry_group.GroupComment',
created_datetime=testfeedbackset2.current_deadline() +
timezone.timedelta(hours=1),
published_datetime=testfeedbackset2.current_deadline() +
timezone.timedelta(hours=1),
user=examiner.relatedexaminer.user,
user_role='examiner',
part_of_grading=True,
feedback_set=testfeedbackset2)
feedbackset_queryset = builder_base.get_feedbackfeed_builder_queryset(
group=testgroup, requestuser=testuser, devilryrole='student')
built_timeline = feedbackfeed_timelinebuilder.FeedbackFeedTimelineBuilder(
feedbacksets=feedbackset_queryset, group=testgroup)
built_timeline.build()
listbuilder_list = listbuilder.TimelineListBuilderList.from_built_timeline(
built_timeline,
group=testgroup,
devilryrole='student',
assignment=testassignment)
self.assertTrue(
isinstance(listbuilder_list.renderable_list[0],
listbuilder.StudentGroupCommentItemValue))
self.assertTrue(
isinstance(listbuilder_list.renderable_list[1],
listbuilder.DeadlineExpiredItemValue))
self.assertTrue(
isinstance(listbuilder_list.renderable_list[2],
listbuilder.ExaminerGroupCommentItemValue))
self.assertTrue(
isinstance(listbuilder_list.renderable_list[3],
listbuilder.GradeItemValue))
self.assertTrue(
isinstance(listbuilder_list.renderable_list[4],
listbuilder.DeadlineCreatedItemValue))
self.assertTrue(
isinstance(listbuilder_list.renderable_list[5],
listbuilder.StudentGroupCommentItemValue))
self.assertTrue(
isinstance(listbuilder_list.renderable_list[6],
listbuilder.DeadlineExpiredItemValue))
self.assertTrue(
isinstance(listbuilder_list.renderable_list[7],
listbuilder.ExaminerGroupCommentItemValue))
self.assertTrue(
isinstance(listbuilder_list.renderable_list[8],
listbuilder.GradeItemValue))
def test_complete_example(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)
candidate = mommy.make('core.Candidate',
assignment_group=testgroup,
relatedstudent__user__fullname='Test User1',
relatedstudent__user__shortname='*****@*****.**')
examiner = mommy.make('core.Examiner',
assignmentgroup=testgroup,
relatedexaminer_user__fullname='Test User2',
relatedexaminer__user__shortname='*****@*****.**')
# First feedbackset published with comments and grading
testfeedbackset1 = group_mommy.feedbackset_first_attempt_published(
grading_published_datetime=testassignment.first_deadline + timezone.timedelta(days=1),
grading_points=10,
created_by=examiner.relatedexaminer.user,
created_datetime=testassignment.publishing_time,
is_last_in_group=None,
group=testgroup,
grading_published_by=examiner.relatedexaminer.user)
mommy.make('devilry_group.GroupComment',
created_datetime=testfeedbackset1.current_deadline() - timezone.timedelta(hours=1),
published_datetime=testfeedbackset1.current_deadline() - timezone.timedelta(hours=1),
user=candidate.relatedstudent.user,
user_role='student',
feedback_set=testfeedbackset1)
mommy.make('devilry_group.GroupComment',
created_datetime=testfeedbackset1.current_deadline() + timezone.timedelta(hours=1),
published_datetime=testfeedbackset1.current_deadline() + timezone.timedelta(hours=1),
user=examiner.relatedexaminer.user,
user_role='examiner',
part_of_grading=True,
feedback_set=testfeedbackset1)
# Second feedbackset with comments and grading
testfeedbackset2 = group_mommy.feedbackset_new_attempt_published(
grading_published_datetime=testfeedbackset1.grading_published_datetime + timezone.timedelta(days=4),
grading_points=10,
created_datetime=testfeedbackset1.grading_published_datetime + timezone.timedelta(hours=10),
deadline_datetime=testfeedbackset1.grading_published_datetime + timezone.timedelta(days=3),
created_by=examiner.relatedexaminer.user,
group=testgroup,
grading_published_by=examiner.relatedexaminer.user)
mommy.make('devilry_group.GroupComment',
created_datetime=testfeedbackset2.current_deadline() - timezone.timedelta(hours=1),
published_datetime=testfeedbackset2.current_deadline() - timezone.timedelta(hours=1),
user=candidate.relatedstudent.user,
user_role='student',
feedback_set=testfeedbackset2)
mommy.make('devilry_group.GroupComment',
created_datetime=testfeedbackset2.current_deadline() + timezone.timedelta(hours=1),
published_datetime=testfeedbackset2.current_deadline() + timezone.timedelta(hours=1),
user=examiner.relatedexaminer.user,
user_role='examiner',
part_of_grading=True,
feedback_set=testfeedbackset2)
built_timeline = FeedbackFeedTimelineBuilder(
group=testgroup,
requestuser=testuser,
devilryrole='student'
)
built_timeline.build()
builder_list = built_timeline.get_as_list()
self.assertEquals(builder_list[0]['type'], 'comment')
self.assertEquals(builder_list[1]['type'], 'deadline_expired')
self.assertEquals(builder_list[2]['type'], 'comment')
self.assertEquals(builder_list[3]['type'], 'grade')
self.assertEquals(builder_list[4]['type'], 'deadline_created')
self.assertEquals(builder_list[5]['type'], 'comment')
self.assertEquals(builder_list[6]['type'], 'deadline_expired')
self.assertEquals(builder_list[7]['type'], 'comment')
self.assertEquals(builder_list[8]['type'], 'grade')
def test_only_distinct_deadlines_listed_multiple(self):
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start')
testuser = mommy.make(settings.AUTH_USER_MODEL)
# Groups with published FeedbackSets using first_deadline
testgroup_first_deadline1 = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
testgroup_first_deadline2 = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
group_mommy.feedbackset_first_attempt_published(
group=testgroup_first_deadline1)
group_mommy.feedbackset_first_attempt_published(
group=testgroup_first_deadline2)
mommy.make('core.Examiner',
assignmentgroup=testgroup_first_deadline1,
relatedexaminer__user=testuser)
mommy.make('core.Examiner',
assignmentgroup=testgroup_first_deadline2,
relatedexaminer__user=testuser)
# Groups with published FeedbackSets as new attempt published
testgroup_new_attempt1 = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
testgroup_new_attempt2 = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
new_attempt_deadline = timezone.now() - timezone.timedelta(days=1)
new_attempt_deadline = new_attempt_deadline.replace(microsecond=0)
group_mommy.feedbackset_first_attempt_published(
group=testgroup_new_attempt1)
group_mommy.feedbackset_first_attempt_published(
group=testgroup_new_attempt2)
group_mommy.feedbackset_new_attempt_published(
group=testgroup_new_attempt1,
deadline_datetime=new_attempt_deadline)
group_mommy.feedbackset_new_attempt_published(
group=testgroup_new_attempt2,
deadline_datetime=new_attempt_deadline)
mommy.make('core.Examiner',
assignmentgroup=testgroup_new_attempt1,
relatedexaminer__user=testuser)
mommy.make('core.Examiner',
assignmentgroup=testgroup_new_attempt2,
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.assertEquals(
2,
mockresponse.selector.count(
'.django-cradmin-listbuilder-itemvalue-titledescription'))
deadline_list = [
elem.alltext_normalized for elem in mockresponse.selector.list(
'.django-cradmin-listbuilder-itemvalue-titledescription-title')
]
self.assertEquals(2, len(deadline_list))
self.assertIn(
'{} (Assignment first deadline)'.format(
defaultfilters.date(testassignment.first_deadline,
'DATETIME_FORMAT')), deadline_list)
self.assertIn(
defaultfilters.date(timezone.localtime(new_attempt_deadline),
'DATETIME_FORMAT'), deadline_list)
def test_anonymous_query_count(self):
testassignment = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start',
anonymizationmode=core_models.Assignment.
ANONYMIZATIONMODE_FULLY_ANONYMOUS)
testuser = mommy.make(settings.AUTH_USER_MODEL)
# Groups with published FeedbackSets using first_deadline
testgroup_first_deadline1 = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
testgroup_first_deadline2 = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
group_mommy.feedbackset_first_attempt_published(
group=testgroup_first_deadline1)
group_mommy.feedbackset_first_attempt_published(
group=testgroup_first_deadline2)
mommy.make('core.Examiner',
assignmentgroup=testgroup_first_deadline1,
relatedexaminer__user=testuser)
mommy.make('core.Examiner',
assignmentgroup=testgroup_first_deadline2,
relatedexaminer__user=testuser)
mommy.make('core.Examiner', assignmentgroup=testgroup_first_deadline1)
mommy.make('core.Examiner', assignmentgroup=testgroup_first_deadline1)
mommy.make('core.Examiner', assignmentgroup=testgroup_first_deadline2)
mommy.make('core.Examiner', assignmentgroup=testgroup_first_deadline2)
mommy.make('core.Candidate',
assignment_group=testgroup_first_deadline1)
mommy.make('core.Candidate',
assignment_group=testgroup_first_deadline1)
mommy.make('core.Candidate',
assignment_group=testgroup_first_deadline2)
mommy.make('core.Candidate',
assignment_group=testgroup_first_deadline2)
# Groups with published FeedbackSets as new attempt published
testgroup_new_attempt1 = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
testgroup_new_attempt2 = mommy.make('core.AssignmentGroup',
parentnode=testassignment)
new_attempt_deadline = timezone.now() - timezone.timedelta(days=1)
new_attempt_deadline = new_attempt_deadline.replace(microsecond=0)
group_mommy.feedbackset_first_attempt_published(
group=testgroup_new_attempt1)
group_mommy.feedbackset_first_attempt_published(
group=testgroup_new_attempt2)
group_mommy.feedbackset_new_attempt_published(
group=testgroup_new_attempt1,
deadline_datetime=new_attempt_deadline)
group_mommy.feedbackset_new_attempt_published(
group=testgroup_new_attempt2,
deadline_datetime=new_attempt_deadline)
mommy.make('core.Examiner',
assignmentgroup=testgroup_new_attempt1,
relatedexaminer__user=testuser)
mommy.make('core.Examiner',
assignmentgroup=testgroup_new_attempt2,
relatedexaminer__user=testuser)
mommy.make('core.Examiner', assignmentgroup=testgroup_new_attempt1)
mommy.make('core.Examiner', assignmentgroup=testgroup_new_attempt1)
mommy.make('core.Examiner', assignmentgroup=testgroup_new_attempt2)
mommy.make('core.Examiner', assignmentgroup=testgroup_new_attempt2)
mommy.make('core.Candidate', assignment_group=testgroup_new_attempt1)
mommy.make('core.Candidate', assignment_group=testgroup_new_attempt1)
mommy.make('core.Candidate', assignment_group=testgroup_new_attempt2)
mommy.make('core.Candidate', assignment_group=testgroup_new_attempt2)
with self.assertNumQueries(3):
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)
