class TestRestAssignmentListing(TestCase):
def setUp(self):
self.testhelper = TestHelper()
#self.testhelper.add(nodes='uni:admin(uniadmin)',
#subjects=['duck2000:admin(adminone,admintwo):ln(Something fancy)',
#'duck3000',
#'duck1000:admin(adminone)',
#'duck4000:admin(adminone,admintwo,singleadmin)'])
self.client = RestClient()
def _get(self, **data):
return self.client.rest_get(reverse('devilry_examiner-rest-assignmentlisting'), **data)
def _getas(self, username, **data):
self.client.login(username=username, password='******')
return self._get(**data)
def test_get(self):
self.testhelper.create_user('examiner1')
content, response = self._getas('examiner1')
self.assertEquals(response.status_code, 200)
self.assertEquals(content, ['Hello', 'world'])
def test_get_noauth(self):
content, response = self._get()
self.assertEquals(response.status_code, 401)
class TestLanguageSelect(TestCase):
def setUp(self):
self.client = RestClient()
self.url = '/devilry_i18n/rest/languageselect'
self.testhelper = TestHelper()
self.testhelper.create_user('testuser')
def _getas(self, username):
self.client.login(username=username, password='******')
return self.client.rest_get(self.url)
def _get_languagecode(self, username):
user = User.objects.get(username=username)
return user.devilryuserprofile.languagecode
def _set_languagecode(self, username, languagecode):
profile = User.objects.get(username=username).devilryuserprofile
profile.languagecode = languagecode
profile.save()
def test_get_languagecode_none(self):
self.assertEquals(self._get_languagecode('testuser'), None)
content, response = self._getas('testuser')
self.assertEquals(response.status_code, 200)
self.assertEquals(content['preferred'], None)
self.assertEquals(content['selected']['languagecode'],
settings.LANGUAGE_CODE)
def test_get_languagecode_set(self):
self._set_languagecode('testuser', 'nb')
content, response = self._getas('testuser')
self.assertEquals(response.status_code, 200)
self.assertEquals(content['preferred'], 'nb')
self.assertEquals(content['selected']['languagecode'], 'nb')
def _putas(self, username, data):
self.client.login(username=username, password='******')
return self.client.rest_put(self.url, data)
def test_put(self):
content, response = self._putas('testuser', {'preferred': 'nb'})
self.assertEquals(response.status_code, 200)
self.assertEquals(content['preferred'], 'nb')
self.assertEquals(self._get_languagecode('testuser'), 'nb')
def test_put_invalid(self):
content, response = self._putas('testuser', {'preferred': 'invalid-code'})
self.assertEquals(response.status_code, 400)
self.assertEquals(content['field_errors']['preferred'],
[u'Invalid languagecode: invalid-code'])
def test_put_with_extradata(self):
content, response = self._putas('testuser', {'preferred': 'nb',
'selected': {'ignored': 'data'},
'available': ['ignored']})
self.assertEquals(response.status_code, 200)
self.assertEquals(content['preferred'], 'nb')
self.assertEquals(self._get_languagecode('testuser'), 'nb')
class TestRestAggregatedStudentInfo(TestCase):
def setUp(self):
self.testhelper = TestHelper()
self.client = RestClient()
self.testhelper.add(nodes='uni:admin(uniadmin)',
subjects=['sub'],
periods=['p1:begins(-1)'],
assignments=['a1'])
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1,student2):examiner(examiner1).d1:ends(5)')
self.group = self.testhelper.sub_p1_a1_g1
def _get(self, user_id):
return self.client.rest_get(reverse('devilry_nodeadmin-aggregatedstudentinfo', kwargs={'user_id': user_id}))
def _getas(self, username, id):
self.client.login(username=username, password='******')
return self._get(id)
def test_get(self):
content, response = self._getas('uniadmin', self.testhelper.student1.id)
self.assertEquals(response.status_code, 200)
user = {u'username': u'student1',
u'displayname': u'student1',
u'id': 2, u'full_name': None,
u'email': u'*****@*****.**'}
self.assertEquals(content['user'], user)
grouped_by_hierarky = content['grouped_by_hierarky'][0]
self.assertEquals(set(grouped_by_hierarky.keys()), set([u'long_name', u'id', u'short_name', u'periods']))
period = grouped_by_hierarky['periods'][0]
self.assertEquals(set(period.keys()), set([u'short_name', u'assignments',
u'is_relatedstudent', u'start_time',
u'is_active', u'qualified_forexams',
u'long_name', u'end_time', u'id']))
assignments = period['assignments'][0]
self.assertEquals(set(period.keys()), set([u'short_name', u'assignments',
u'is_relatedstudent', u'start_time',
u'is_active', u'qualified_forexams',
u'long_name', u'end_time', u'id']))
groups = assignments['groups'][0]
self.assertEquals(set(groups.keys()), set([u'status', u'active_feedback', u'id']))
def test_get_noauth(self):
content, response = self._get(self.testhelper.student1.id)
self.assertEquals(response.status_code, 401)
class TestRestRecentDeliveries(TestCase):
def setUp(self):
self.client = RestClient()
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['p1:begins(-1)'],
assignments=['a1'])
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1).d1')
self.group = self.testhelper.sub_p1_a1_g1
self.url = '/devilry_student/rest/recent-deliveries/'
def _getas(self, username):
self.client.login(username=username, password='******')
return self.client.rest_get(self.url)
def test_nobody(self):
fileinfo = {'ok.py': ['print ', 'meh']}
self.testhelper.add_delivery('sub.p1.a1.g1', fileinfo)
self.testhelper.create_user('nobody')
content, response = self._getas('nobody')
self.assertEquals(response.status_code, 200)
self.assertEquals(content, [])
def test_recent_deliveries_minimal(self):
fileinfo = {'ok.py': ['print ', 'meh']}
self.testhelper.add_delivery('sub.p1.a1.g1', fileinfo)
content, response = self._getas('student1')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 1)
self.assertEquals(set(content[0].keys()),
set(['id', 'assignment', 'period', 'subject',
'time_of_delivery', 'group', 'number']))
assignment = self.group.parentnode
period = self.group.parentnode.parentnode
subject = self.group.parentnode.parentnode.parentnode
self.assertEquals(content[0]['assignment'],
{u'id': assignment.id, u'long_name': u'A1', u'short_name': u'a1'})
self.assertEquals(content[0]['period'],
{u'id': period.id, u'long_name': u'P1', u'short_name': u'p1'})
self.assertEquals(content[0]['subject'],
{u'id': subject.id, u'long_name': u'Sub', u'short_name': u'sub'})
def test_recent_deliveries_over10(self):
fileinfo = {'ok.py': ['print ', 'meh']}
for x in xrange(8):
self.testhelper.add_delivery('sub.p1.a1.g1', fileinfo)
content, response = self._getas('student1')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 6)
class TestRestFindGroups(TestCase):
def setUp(self):
self.client = RestClient()
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['p0:begins(-10):ends(2)',
'p1:begins(-1)',
'p2:begins(5)'],
assignments=['a1'])
self.testhelper.create_user('testuser')
self.url = '/devilry_student/rest/find-groups/'
def _getas(self, username, **data):
self.client.login(username=username, password='******')
return self.client.rest_get(self.url, **data)
def test_find_groups_empty(self):
content, response = self._getas('testuser')
self.assertEquals(response.status_code, 200)
self.assertEquals(content, [])
def test_find_groups(self):
# Add to the past period (should show up)
self.testhelper.add_to_path('uni;sub.p0.a1.gOld:candidate(student1).d1')
# Add to the active period (show show up)
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1).d1')
self.testhelper.add_to_path('uni;sub.p1.a1.g2:candidate(student1,student2).d1')
# Add to the future period (should not show up)
self.testhelper.add_to_path('uni;sub.p2.a1.gFut:candidate(student1).d1')
content, response = self._getas('student1', query='sub')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 3)
self.assertEquals(set(content[0].keys()),
set(['id', 'name', 'assignment', 'period', 'subject']))
groupnames = set([group['name'] for group in content])
self.assertEquals(groupnames, set(['g1', 'g2', 'gOld']))
content, response = self._getas('student1', query='old')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 1)
content, response = self._getas('student1', query='p1 g2')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 1)
self.assertEquals(content[0]['name'], 'g2')
class TestRestRecentFeedbacks(TestCase):
def setUp(self):
self.client = RestClient()
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['p1:begins(-1)'],
assignments=['a1'])
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1):examiner(examiner1).d1')
self.group = self.testhelper.sub_p1_a1_g1
self.url = '/devilry_student/rest/recent-feedbacks/'
def _getas(self, username):
self.client.login(username=username, password='******')
return self.client.rest_get(self.url)
def test_nobody(self):
fileinfo = {'ok.py': ['print ', 'meh']}
self.testhelper.add_delivery('sub.p1.a1.g1', fileinfo)
self.testhelper.create_user('nobody')
content, response = self._getas('nobody')
self.assertEquals(response.status_code, 200)
self.assertEquals(content, [])
def test_recent_feedbacks_minimal(self):
fileinfo = {'ok.py': ['print ', 'meh']}
delivery = self.testhelper.add_delivery('sub.p1.a1.g1', fileinfo)
self.testhelper.add_feedback(delivery,
verdict={'grade': 'F', 'points': 30, 'is_passing_grade': False})
content, response = self._getas('student1')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 1)
self.assertEquals(set(content[0].keys()),
set(['id', 'assignment', 'period', 'subject',
'number', 'last_feedback', 'group']))
def test_recent_deliveries_overflow(self):
fileinfo = {'ok.py': ['print ', 'meh']}
for x in xrange(8):
delivery = self.testhelper.add_delivery('sub.p1.a1.g1', fileinfo)
self.testhelper.add_feedback(delivery,
verdict={'grade': '{0}/100'.format(x), 'points': x, 'is_passing_grade': False})
content, response = self._getas('student1')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 6)
class TestRestPreview(TestCase):
def setUp(self):
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni:admin(uniadmin)',
subjects=['sub'],
periods=['p1:admin(periodadmin):begins(-3):ends(6)'])
self.client = RestClient()
self.testhelper.create_superuser('superuser')
def _get_url(self, periodid):
return reverse('devilry_qualifiesforexam-rest-preview', kwargs={'id': periodid})
def _getas(self, username, periodid, previewdata, pluginsessionid='tst'):
self.client.login(username=username, password='******')
session = self.client.session
session['qualifiesforexam-{0}'.format(pluginsessionid)] = previewdata
session.save()
return self.client.rest_get(self._get_url(periodid),
pluginsessionid=pluginsessionid)
def _test_getas(self, username):
content, response = self._getas(username, self.testhelper.sub_p1.id,
PreviewData(passing_relatedstudentids=[1, 2, 4]))
self.assertEqual(response.status_code, 200)
self.assertEqual(set(content.keys()), set(['pluginoutput', 'perioddata']))
self.assertEqual(content['pluginoutput'],
{u'passing_relatedstudentids': [1, 2, 4]})
def test_get_as_periodadmin(self):
self._test_getas('periodadmin')
def test_get_as_nodeadmin(self):
self._test_getas('uniadmin')
def test_get_as_superuser(self):
self._test_getas('superuser')
def test_getas_nobody(self):
self.testhelper.create_user('nobody')
content, response = self._getas('nobody', self.testhelper.sub_p1.id,
PreviewData(passing_relatedstudentids=[]))
self.assertEqual(response.status_code, 403)
def test_get_invalid_period(self):
periodid = 10000
self.assertFalse(Period.objects.filter(id=periodid).exists()) # Just to be sure we dont get false positives
content, response = self._getas('periodadmin', periodid, PreviewData(passing_relatedstudentids=[]))
self.assertEqual(response.status_code, 403)
class TestRestAggregatedGroupInfo(TestCase):
def setUp(self):
self.client = RestClient()
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['p1:begins(-1)'],
assignments=['a1:admin(a1admin)'])
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1,student2):examiner(examiner1).d1:ends(5)')
self.testhelper.add_to_path('uni;sub.p1.a1.g1.d2:ends(10)')
self.group = self.testhelper.sub_p1_a1_g1
self.url = '/devilry_subjectadmin/rest/aggregated-groupinfo/{0}'.format(self.group.id)
def _getas(self, username):
self.client.login(username=username, password='******')
return self.client.rest_get(self.url)
def test_nobody(self):
self.testhelper.create_user('nobody')
content, response = self._getas('nobody')
self.assertEquals(response.status_code, 403)
def test_groupinfo(self):
content, response = self._getas('a1admin')
self.assertEquals(response.status_code, 200)
self.assertEquals(set(content.keys()),
set(['id', 'deadlines']))
self.assertEquals(content['id'], self.group.id)
def test_groupinfo_superuser(self):
self.testhelper.create_superuser('superuser')
content, response = self._getas('superuser')
self.assertEquals(response.status_code, 200)
self.assertEquals(set(content.keys()),
set(['id', 'deadlines']))
self.assertEquals(content['id'], self.group.id)
def test_deadlines(self):
content, response = self._getas('a1admin')
deadlines = content['deadlines']
self.assertEquals(len(deadlines), 2)
self.assertEquals(set(deadlines[0].keys()),
set(['id', 'deadline', 'deliveries', 'text',
'offset_from_now', 'in_the_future']))
class TestRestDetailedPeriodOverview(TestCase):
def setUp(self):
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni:admin(uniadmin)',
subjects=['sub'],
periods=['p1:admin(periodadmin):begins(-3):ends(6)'])
self.client = RestClient()
self.testhelper.create_superuser('superuser')
def _get_url(self, periodid):
return reverse('devilry-subjectadmin-rest-detailedperiodoverview', kwargs={'id': periodid})
def _getas(self, username, periodid):
self.client.login(username=username, password='******')
return self.client.rest_get(self._get_url(periodid))
def _test_get_as(self, username):
content, response = self._getas(username, self.testhelper.sub_p1.id)
self.assertEqual(response.status_code, 200)
# NOTE: This is tested in more detail in the API that generates the data (devilry.utils.groups_groupedby_relatedstudent_and_assignment)
self.assertEqual(set(content.keys()),
set([u'students_with_feedback_that_is_candidate_but_not_in_related',
u'students_with_no_feedback_that_is_candidate_but_not_in_related',
u'relatedstudents', u'assignments']))
def test_getlist_as_periodadmin(self):
self._test_get_as('periodadmin')
def test_getlist_as_nodeadmin(self):
self._test_get_as('uniadmin')
def test_getlist_as_superuser(self):
self._test_get_as('superuser')
def test_get_as_nobody(self):
self.testhelper.create_user('nobody')
content, response = self._getas('nobody', self.testhelper.sub_p1.id)
self.assertEqual(response.status_code, 403)
def test_get_invalid_id(self):
content, response = self._getas('periodadmin', 10000)
self.assertEqual(response.status_code, 403)
class TestRestSearchStudentContent(TestCase, AssertSearchResultMixin):
def setUp(self):
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni:ln(Test Uni)',
subjects=['sub:ln(Test Sub)'],
periods=['p1:begins(-2):ln(Test P1)'],
assignments=['a1:ln(Test A1)'],
assignmentgroups=[
'TestGroup1:candidate(student1)',
'TestGroup2:candidate(student2,student1)',
'TestGroup3:candidate(student2)',
'TestGroup4:candidate(student3):examiner(student1)'
]
)
self.client = RestClient()
self.url = reverse('devilry_search_studentcontent')
def _getas(self, username, **data):
self.client.login(username=username, password='******')
return self.client.rest_get(self.url, **data)
def test_perms_student(self):
with HaystackTestSettings():
content, response = self._getas('student1', search='Test')
matches = content['matches']
self.assertEqual(len(matches), 2)
self.assert_has_search_result(matches, type='core_assignmentgroup',
title='Test A1', name='TestGroup1')
self.assert_has_search_result(matches, type='core_assignmentgroup',
title='Test A1', name='TestGroup2')
def test_perms_student_unpublished(self):
self.testhelper.sub_p1_a1.publishing_time = datetime.now() + timedelta(days=1)
self.testhelper.sub_p1_a1.save()
with HaystackTestSettings():
content, response = self._getas('student1', search='Test')
matches = content['matches']
self.assertEqual(len(matches), 0)
class TestRestExaminerStats(TestCase):
def setUp(self):
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni:admin(uniadmin)',
subjects=['sub'],
periods=['p1:begins(-3):ends(6)'],
assignments=['a1:admin(assignmentadmin)']
)
self.client = RestClient()
self.testhelper.create_superuser('superuser')
def _get_url(self, assignmentid):
return reverse('devilry-subjectadmin-rest-examinerstats', kwargs={'id': assignmentid})
def _getas(self, username, periodid):
self.client.login(username=username, password='******')
return self.client.rest_get(self._get_url(periodid))
def _test_get_as(self, username):
content, response = self._getas(username, self.testhelper.sub_p1_a1.id)
self.assertEqual(response.status_code, 200)
def test_perms_as_assignmentadmin(self):
self._test_get_as('assignmentadmin')
def test_perms_as_nodeadmin(self):
self._test_get_as('uniadmin')
def test_perms_as_superuser(self):
self._test_get_as('superuser')
def test_perms_as_nobody(self):
self.testhelper.create_user('nobody')
content, response = self._getas('nobody', self.testhelper.sub_p1_a1.id)
self.assertEqual(response.status_code, 403)
def test_perms_invalid_id(self):
content, response = self._getas('assignmentadmin', 10000)
self.assertEqual(response.status_code, 403)
class TestRestToplevelNodeListing(TestCase):
def setUp(self):
self.testhelper = TestHelper()
self.testhelper.add(nodes="uni:admin(uniadmin).inf:admin(infadmin)")
self.testhelper.add(nodes="uni.fys:admin(fysadmin)")
self.testhelper.add(nodes="uni.fys2:admin(fysadmin)")
self.client = RestClient()
def _geturl(self):
return reverse("devilry_nodeadmin-rest_toplevel_nodes")
def test_get_as_nodeadmin(self):
self.client.login(username="******", password="******")
content, response = self.client.rest_get(self._geturl())
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 1)
self.assertEquals(content[0]["short_name"], "inf")
def test_multiget_as_nodeadmin(self):
self.client.login(username="******", password="******")
content, response = self.client.rest_get(self._geturl())
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 2)
self.assertEquals([n["short_name"] for n in content], ["fys", "fys2"])
def test_get_as_superuser(self):
self.testhelper.create_superuser("super")
self.client.login(username="******", password="******")
content, response = self.client.rest_get(self._geturl())
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 1)
self.assertEquals(content[0]["short_name"], "uni")
def test_nodata(self):
self.testhelper.create_user("nobody")
self.client.login(username="******", password="******")
content, response = self.client.rest_get(self._geturl())
self.assertEquals(response.status_code, 200)
self.assertEquals(content, [])
class TestRestDeadlinesBulkCreate(TestCase):
def setUp(self):
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['p1:begins(-2)']) # 2 months ago
self.testhelper.sub_p1.start_time = datetime(2000, 1, 1, 22, 30, 49)
self.testhelper.sub_p1.save()
self.testhelper.add_to_path('uni;sub.p1.a1:admin(adm):pub(0)') # 0 days after period begins + 2 sec
self.client = RestClient()
for groupnum in xrange(3):
# deadline 5 days after assignment starts
self.testhelper.add_to_path('uni;sub.p1.a1.g{0}:candidate(cand1):examiner(exam1).d1:ends(5)'.format(groupnum))
def _geturl(self):
return '/devilry_subjectadmin/rest/deadlinesbulk/{0}/'.format(self.testhelper.sub_p1_a1.id)
def _postas(self, username, data):
self.client.login(username=username, password='******')
return self.client.rest_post(self._geturl(), data)
def _itergroups(self):
for groupnum in xrange(3):
group_id = getattr(self.testhelper, 'sub_p1_a1_g{0}'.format(groupnum)).id
group = AssignmentGroup.objects.get(id=group_id)
yield group
def test_post_no_matching_groups(self):
for group in self._itergroups():
deadlines = group.deadlines.all().order_by('-deadline')
self.assertEquals(group.feedback, None)
new_deadline = datetime(2004, 12, 24, 20, 30)
content, response = self._postas('adm', {'deadline': format_datetime(new_deadline),
'text': 'Created',
'createmode': 'failed'})
self.assertEquals(response.status_code, 400)
self.assertEquals(content['field_errors']['createmode'], ['The given option did not match any groups.'])
def test_post_createmode_failed(self):
self.testhelper.add_delivery('sub.p1.a1.g1', {'bad.py': ['print ', 'bah']})
self.testhelper.add_feedback('sub.p1.a1.g1', verdict={'grade': 'F', 'points': 30, 'is_passing_grade': False})
g1 = AssignmentGroup.objects.get(id=self.testhelper.sub_p1_a1_g1.id)
self.assertFalse(g1.is_open)
new_deadline = datetime(2004, 12, 24, 20, 30)
self.assertEquals(Deadline.objects.filter(deadline=new_deadline).count(), 0)
content, response = self._postas('adm', {'deadline': format_datetime(new_deadline),
'text': 'Created',
'createmode': 'failed'})
# Check response
self.assertEquals(response.status_code, 201)
self.assertEquals(decode_bulkdeadline_id(content['bulkdeadline_id'])[0],
new_deadline)
self.assertEquals(len(content['groups']), 1)
self.assertEquals(content['text'], 'Created')
self.assertEquals(content['deadline'], format_datetime(new_deadline))
# Check actual data
self.assertEquals(Deadline.objects.filter(deadline=new_deadline).count(), 1)
g1 = AssignmentGroup.objects.get(id=self.testhelper.sub_p1_a1_g1.id)
deadlines = g1.deadlines.all().order_by('-deadline')
self.assertEquals(len(deadlines), 2)
self.assertEquals(deadlines[0].deadline, new_deadline)
self.assertEquals(deadlines[0].text, 'Created')
self.assertTrue(g1.is_open) # Group was automatically opened in devilry.apps.core.models.Deadline.save()
def test_post_createmode_failed_or_no_feedback(self):
# Fail g0
self.testhelper.add_delivery('sub.p1.a1.g0', {'bad.py': ['print ', 'bah']})
self.testhelper.add_feedback('sub.p1.a1.g0', verdict={'grade': 'F', 'points': 30, 'is_passing_grade': False})
# Pass g1
self.testhelper.add_delivery('sub.p1.a1.g1', {'good.py': ['print ', 'bah']})
self.testhelper.add_feedback('sub.p1.a1.g1', verdict={'grade': 'A', 'points': 100, 'is_passing_grade': True})
# g2 has no feedback
self.assertEquals(self.testhelper.sub_p1_a1_g2.feedback, None)
new_deadline = datetime(2004, 12, 24, 20, 30)
self.assertEquals(Deadline.objects.filter(deadline=new_deadline).count(), 0)
content, response = self._postas('adm', {'deadline': format_datetime(new_deadline),
'text': 'Created',
'createmode': 'failed-or-no-feedback'})
# Check response
self.assertEquals(response.status_code, 201)
self.assertEquals(len(content['groups']), 2)
# Check actual data
self.assertEquals(Deadline.objects.filter(deadline=new_deadline).count(), 2)
g0 = self.testhelper.sub_p1_a1_g0
g2 = self.testhelper.sub_p1_a1_g2
for group in (g0, g2):
deadlines = group.deadlines.all().order_by('-deadline')
self.assertEquals(len(deadlines), 2)
self.assertEquals(deadlines[0].deadline, new_deadline)
self.assertEquals(deadlines[0].text, 'Created')
g1 = self.testhelper.sub_p1_a1_g1
self.assertEquals(g1.deadlines.count(), 1) # We did not a deadline to g1 because they have passing grade
def test_post_createmode_no_deadlines(self):
self.assertEquals(self.testhelper.sub_p1_a1_g1.deadlines.count(), 1)
self.testhelper.add_to_path('uni;sub.p1.a1.extragroup')
self.assertEquals(self.testhelper.sub_p1_a1_extragroup.deadlines.count(), 0)
new_deadline = datetime(2004, 12, 24, 20, 30)
self.assertEquals(Deadline.objects.filter(deadline=new_deadline).count(), 0)
content, response = self._postas('adm', {'deadline': format_datetime(new_deadline),
'text': 'Created',
'createmode': 'no-deadlines'})
# Check response
self.assertEquals(response.status_code, 201)
self.assertEquals(decode_bulkdeadline_id(content['bulkdeadline_id'])[0],
new_deadline)
self.assertEquals(len(content['groups']), 1)
self.assertEquals(content['text'], 'Created')
self.assertEquals(content['deadline'], format_datetime(new_deadline))
# Check actual data
self.assertEquals(Deadline.objects.filter(deadline=new_deadline).count(), 1)
extragroup = AssignmentGroup.objects.get(id=self.testhelper.sub_p1_a1_extragroup.id)
deadlines = extragroup.deadlines.all()
self.assertEquals(len(deadlines), 1)
self.assertEquals(deadlines[0].deadline, new_deadline)
self.assertEquals(deadlines[0].text, 'Created')
self.assertTrue(extragroup.is_open) # Group was automatically opened in devilry.apps.core.models.Deadline.save()
def test_post_createmode_specific_groups(self):
self.assertEquals(self.testhelper.sub_p1_a1_g1.deadlines.count(), 1)
self.assertEquals(self.testhelper.sub_p1_a1_g2.deadlines.count(), 1)
new_deadline = datetime(2004, 12, 24, 20, 30)
self.assertEquals(Deadline.objects.filter(deadline=new_deadline).count(), 0)
content, response = self._postas('adm', {'deadline': format_datetime(new_deadline),
'text': 'Created',
'group_ids': [self.testhelper.sub_p1_a1_g1.id,
self.testhelper.sub_p1_a1_g2.id],
'createmode': 'specific-groups'})
# Check response
self.assertEquals(response.status_code, 201)
self.assertEquals(decode_bulkdeadline_id(content['bulkdeadline_id'])[0],
new_deadline)
self.assertEquals(len(content['groups']), 2)
self.assertEquals(content['text'], 'Created')
self.assertEquals(content['deadline'], format_datetime(new_deadline))
# Check actual data
self.assertEquals(Deadline.objects.filter(deadline=new_deadline).count(), 2)
g1 = self.testhelper.reload_from_db(self.testhelper.sub_p1_a1_g1)
deadlines = g1.deadlines.all()
self.assertEquals(len(deadlines), 2)
self.assertEquals(deadlines[0].deadline, new_deadline)
self.assertEquals(deadlines[0].text, 'Created')
def test_post_createmode_specific_groups_nogroups(self):
new_deadline = datetime(2004, 12, 24, 20, 30)
self.assertEquals(Deadline.objects.filter(deadline=new_deadline).count(), 0)
content, response = self._postas('adm', {'deadline': format_datetime(new_deadline),
'text': 'Created',
'createmode': 'specific-groups'})
self.assertEquals(response.status_code, 400)
self.assertEquals(content['field_errors']['group_ids'][0],
'``group_ids`` is required when ``createmode=="specific-groups"``.')
def test_post_nobody(self):
self.testhelper.create_user('nobody')
content, response = self._postas('nobody', {})
self.assertEquals(response.status_code, 403)
class TestRestListOrCreateAssignmentRest(TestCase):
def setUp(self):
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni:admin(uniadmin)',
subjects=['duck2000'],
periods=['someperiod:begins(-2):ends(6):admin(periodadm)'],
assignments=['first:admin(firstadmin)',
'second:admin(secondadmin,firstadmin)',
'third'])
self.testhelper.add_to_path('uni;duck9000.otherperiod:begins(-3):ends(6).someassignment:admin(firstadmin)')
self.client = RestClient()
self.url = '/devilry_subjectadmin/rest/assignment/'
self.testhelper.create_user('nobody')
def _listas(self, username, **data):
self.client.login(username=username, password='******')
return self.client.rest_get(self.url, **data)
def test_list(self):
content, response = self._listas('firstadmin')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 3)
self.assertEquals(set(content[0].keys()),
set(['id', 'parentnode', 'etag', 'short_name', 'long_name',
'publishing_time', 'delivery_types',
'is_published', 'publishing_time_offset_from_now',
'scale_points_percent', 'first_deadline',
'anonymous', 'deadline_handling']))
def test_list_nonadmin(self):
self.testhelper.create_user('otheruser')
content, response = self._listas('otheruser')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 0)
def test_list_in_subject(self):
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['per'],
assignments=['a', 'b'])
content, response = self._listas('uniadmin',
parentnode=self.testhelper.sub_per.id)
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 2)
shortnames = set([a['short_name'] for a in content])
self.assertEquals(shortnames, set(['a', 'b']))
def _createas(self, username, data):
self.client.login(username=username, password='******')
return self.client.rest_post(self.url, data)
def test_create(self):
content, response = self._createas('periodadm',
{'short_name': 'test',
'long_name': 'Test',
'admins': [],
'anonymous': True,
'publishing_time': isoformat_relativetime(days=2),
'first_deadline': isoformat_relativetime(days=3),
'scale_points_percent': 100,
'deadline_handling': 0,
'delivery_types': 0,
'parentnode': self.testhelper.duck2000_someperiod.id})
self.assertEquals(response.status_code, 201)
self.assertEquals(content['delivery_types'], 0)
self.assertEquals(content['scale_points_percent'], 100)
self.assertTrue(content['publishing_time'] != None)
self.assertTrue(content['first_deadline'] != None)
self.assertEquals(content['long_name'], 'Test')
self.assertEquals(content['short_name'], 'test')
self.assertEquals(content['anonymous'], True)
self.assertEquals(content['parentnode'], self.testhelper.duck2000_someperiod.id)
created = Assignment.objects.get(id=content['id'])
self.assertEquals(created.short_name, 'test')
self.assertEquals(created.long_name, 'Test')
self.assertEquals(created.delivery_types, 0)
self.assertEquals(created.anonymous, True)
self.assertEquals(created.scale_points_percent, 100)
self.assertEquals(created.deadline_handling, 0)
self.assertEquals(created.parentnode.id, self.testhelper.duck2000_someperiod.id)
admins = created.admins.all()
self.assertEquals(len(admins), 0)
def test_create_nobody(self):
content, response = self._createas('nobody',
{'short_name': 'test',
'long_name': 'Test',
'admins': [],
'publishing_time': isoformat_relativetime(days=-2),
'scale_points_percent': 100,
'deadline_handling': 0,
'delivery_types': 0,
'parentnode': self.testhelper.duck2000_someperiod.id})
self.assertEquals(response.status_code, 403)
self.assertEquals(content['detail'], 'Permission denied')
def test_create_admins(self):
self.testhelper.create_user('testadmin')
content, response = self._createas('uniadmin',
{'short_name': 'test',
'long_name': 'Test',
'admins': [{'id': self.testhelper.testadmin.id}],
'publishing_time': isoformat_relativetime(days=-2),
'scale_points_percent': 100,
'deadline_handling': 0,
'delivery_types': 0,
'parentnode': self.testhelper.duck2000.id})
self.assertEquals(response.status_code, 201)
created = Assignment.objects.get(id=content['id'])
admins = created.admins.all()
self.assertEquals(len(admins), 1)
self.assertEquals(admins[0].username, 'testadmin')
class TestRestSearchAdminContent(TestCase, AssertSearchResultMixin):
def setUp(self):
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni:admin(uniadmin):ln(Test Uni)',
subjects=['sub:admin(subadmin):ln(Test Sub)'],
periods=['p1:begins(-2):admin(p1admin):ln(Test P1)'],
assignments=['a1:admin(a1admin):ln(Test A1)'],
assignmentgroups=['TestGroup1:candidate(student1)']
)
self.client = RestClient()
self.url = reverse('devilry_search_admincontent')
def _getas(self, username, **data):
self.client.login(username=username, password='******')
return self.client.rest_get(self.url, **data)
def _test_perms_topnodeorsuper(self, username):
with HaystackTestSettings():
content, response = self._getas(username, search='Test')
matches = content['matches']
self.assertEqual(len(matches), 5)
self.assert_has_search_result(matches, type='core_node', title='Test Uni')
self.assert_has_search_result(matches, type='core_subject', title='Test Sub')
self.assert_has_search_result(matches, type='core_period', title='Test P1')
self.assert_has_search_result(matches, type='core_assignment', title='Test A1')
self.assert_has_search_result(matches, type='core_assignmentgroup',
title='Test A1', students=['student1'])
def test_perms_uniadmin(self):
self._test_perms_topnodeorsuper('uniadmin')
def test_perms_superuser(self):
self.testhelper.create_superuser('superuser')
self._test_perms_topnodeorsuper('superuser')
def test_perms_subjectadmin(self):
with HaystackTestSettings():
content, response = self._getas('subadmin', search='Test')
matches = content['matches']
self.assertEqual(len(matches), 4)
self.assert_has_search_result(matches, type='core_subject', title='Test Sub')
self.assert_has_search_result(matches, type='core_period', title='Test P1')
self.assert_has_search_result(matches, type='core_assignment', title='Test A1')
self.assert_has_search_result(matches, type='core_assignmentgroup',
title='Test A1', students=['student1'])
def test_perms_periodadmin(self):
with HaystackTestSettings():
content, response = self._getas('p1admin', search='Test')
matches = content['matches']
self.assertEqual(len(matches), 3)
self.assert_has_search_result(matches, type='core_period', title='Test P1')
self.assert_has_search_result(matches, type='core_assignment', title='Test A1')
self.assert_has_search_result(matches, type='core_assignmentgroup',
title='Test A1', students=['student1'])
def test_perms_assignmentadmin(self):
with HaystackTestSettings():
content, response = self._getas('a1admin', search='Test')
matches = content['matches']
self.assertEqual(len(matches), 2)
self.assert_has_search_result(matches, type='core_assignment', title='Test A1')
self.assert_has_search_result(matches, type='core_assignmentgroup',
title='Test A1', students=['student1'])
class TestRestAllWhereIsAdmin(TestCase):
def setUp(self):
self.testhelper = TestHelper()
self.client = RestClient()
self.url = '/devilry_subjectadmin/rest/allwhereisadmin/'
def _listas(self, username, **data):
self.client.login(username=username, password='******')
return self.client.rest_get(self.url, **data)
def test_list_emptysubject(self):
self.testhelper.add(nodes='uni',
subjects=['duck2000:admin(adm)'])
content, response = self._listas('adm')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 1)
self.assertEquals(content[0]['short_name'], 'duck2000')
def test_list_emptyperiod(self):
self.testhelper.add(nodes='uni',
subjects=['duck2000:admin(adm)'],
periods=['p1'])
content, response = self._listas('adm')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 1)
self.assertEquals(content[0]['short_name'], 'duck2000')
self.assertEquals(content[0]['is_admin'], True)
self.assertEquals(len(content[0]['periods']), 1)
self.assertEquals(content[0]['periods'][0]['short_name'], 'p1')
self.assertEquals(content[0]['periods'][0]['is_admin'], False)
self.testhelper.add(nodes='uni',
subjects=['duck3000'],
periods=['p1:admin(adm)'])
content, response = self._listas('adm')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 2)
def test_list_nobody(self):
self.testhelper.create_user('nobody')
self.testhelper.add(nodes='uni',
subjects=['duck2000'])
content, response = self._listas('nobody')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 0)
def test_list(self):
self.testhelper.add(nodes='uni',
subjects=['duck2000:admin(adm)', 'duck3000', 'duck4000'])
self.testhelper.add_to_path('uni;duck2000.p2000')
self.testhelper.add_to_path('uni;duck3000.p3000:admin(adm)')
self.testhelper.add_to_path('uni;duck4000.p4000.a1:admin(adm)')
content, response = self._listas('adm')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 3)
self.assertEquals(content[0]['short_name'], 'duck2000')
self.assertEquals(content[0]['is_admin'], True)
self.assertEquals(content[0]['can_administer'], True)
self.assertEquals(len(content[0]['periods']), 1)
self.assertEquals(content[0]['periods'][0]['short_name'], 'p2000')
self.assertEquals(content[0]['periods'][0]['can_administer'], True)
self.assertEquals(content[0]['periods'][0]['is_admin'], False)
self.assertEquals(content[1]['short_name'], 'duck3000')
self.assertEquals(content[1]['is_admin'], False)
self.assertEquals(content[1]['can_administer'], False)
self.assertEquals(len(content[1]['periods']), 1)
self.assertEquals(content[1]['periods'][0]['short_name'], 'p3000')
self.assertEquals(content[1]['periods'][0]['can_administer'], True)
self.assertEquals(content[1]['periods'][0]['is_admin'], True)
self.assertEquals(content[2]['short_name'], 'duck4000')
self.assertEquals(content[2]['is_admin'], False)
self.assertEquals(content[2]['can_administer'], False)
self.assertEquals(len(content[2]['periods']), 1)
self.assertEquals(content[2]['periods'][0]['can_administer'], False)
self.assertEquals(content[2]['periods'][0]['is_admin'], False)
self.assertEquals(len(content[2]['periods'][0]['assignments']), 1)
self.assertEquals(content[2]['periods'][0]['short_name'], 'p4000')
self.assertEquals(content[2]['periods'][0]['assignments'][0]['can_administer'], True)
self.assertEquals(content[2]['periods'][0]['assignments'][0]['is_admin'], True)
def test_list_active_noassignments(self):
self.testhelper.add(nodes='uni',
subjects=['duck2000:admin(adm)'],
periods=['p1:begins(-20)', 'p2:begins(-1)', 'p3:begins(20)'])
content, response = self._listas('adm', only_active='yes')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 1)
self.assertEquals(content[0]['short_name'], 'duck2000')
self.assertEquals(len(content[0]['periods']), 1)
self.assertEquals(content[0]['periods'][0]['short_name'], 'p2')
def test_list_active(self):
self.testhelper.add(nodes='uni',
subjects=['duck2000:admin(adm)'],
periods=['p1:begins(-20)', 'p2:begins(-1)', 'p3:begins(20)'],
assignments=['a1'])
content, response = self._listas('adm', only_active='yes')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 1)
self.assertEquals(content[0]['short_name'], 'duck2000')
self.assertEquals(len(content[0]['periods']), 1)
self.assertEquals(content[0]['periods'][0]['short_name'], 'p2')
self.assertEquals(len(content[0]['periods'][0]['assignments']), 1)
def test_list_multi_active_assignments(self):
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['p1:begins(-2):ends(6)',
'p2:begins(-1):ends(6)'],
assignments=['a1:admin(a1admin)'])
content, response = self._listas('a1admin', only_active='yes')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 1)
periods = content[0]['periods']
self.assertEquals(len(periods), 2)
self.assertEquals(periods[0]['short_name'], 'p2')
self.assertEquals(periods[1]['short_name'], 'p1')
self.assertEquals(periods[0]['assignments'][0]['short_name'], 'a1')
self.assertEquals(periods[1]['assignments'][0]['short_name'], 'a1')
class TestRestInstanceAssignmentRest(TestCase):
def setUp(self):
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni:admin(uniadmin)',
subjects=['duck2000:admin(duck2000admin)'],
periods=['someperiod:begins(-2):ends(6)'],
assignments=['first:admin(firstadmin)',
'second:admin(secondadmin,firstadmin)',
'third'])
self.client = RestClient()
def _geturl(self, assignmentid):
return '/devilry_subjectadmin/rest/assignment/{0}'.format(assignmentid)
def test_delete_denied(self):
self.client.login(username='******', password='******')
content, response = self.client.rest_delete(self._geturl(self.testhelper.duck2000_someperiod_first.id))
self.assertEquals(response.status_code, 403)
def test_delete(self):
self.client.login(username='******', password='******')
content, response = self.client.rest_delete(self._geturl(self.testhelper.duck2000_someperiod_first.id))
self.assertEquals(response.status_code, 200)
self.assertEquals(content['id'], self.testhelper.duck2000_someperiod_first.id)
self.assertEquals(Assignment.objects.filter(id=self.testhelper.duck2000_someperiod_first.id).count(), 0)
def test_get(self):
self.testhelper.add_to_path('uni;duck2000.someperiod.first.g1:candidate(student1):examiner(examiner1).d1')
self.testhelper.add_to_path('uni;duck2000.someperiod.first.g2:candidate(student2,student3,student4,student5):examiner(examiner1).d1')
self.testhelper.add_delivery('duck2000.someperiod.first.g1', {'bad.py': ['print ', 'bah']})
self.testhelper.add_delivery('duck2000.someperiod.first.g1', {'good.py': ['print ', 'good']})
self.testhelper.add_delivery('duck2000.someperiod.first.g2', {'good.py': ['print ', 'good']})
self.client.login(username='******', password='******')
content, response = self.client.rest_get(self._geturl(self.testhelper.duck2000_someperiod_first.id))
self.assertEquals(response.status_code, 200)
self.assertEquals(content['id'], self.testhelper.duck2000_someperiod_first.id)
self.assertEquals(content['short_name'], self.testhelper.duck2000_someperiod_first.short_name)
self.assertEquals(content['long_name'], self.testhelper.duck2000_someperiod_first.long_name)
self.assertEquals(content['deadline_handling'], self.testhelper.duck2000_someperiod_first.deadline_handling)
self.assertEquals(content['parentnode'], self.testhelper.duck2000_someperiod_first.parentnode_id)
self.assertEquals(content['can_delete'], self.testhelper.duck2000_someperiod_first.can_delete(self.testhelper.duck2000admin))
self.assertEquals(content['can_delete'], False)
self.assertEquals(content['number_of_groups'], 2)
self.assertEquals(content['number_of_deliveries'], 3)
self.assertEquals(content['number_of_candidates'], 5)
self.assertEquals(content['has_valid_grading_setup'], True)
self.assertEquals(content['gradingsystemplugin_title'], 'Passed/failed')
self.assertEquals(set(content.keys()),
set(['short_name', 'long_name', 'admins', 'etag',
'can_delete', 'parentnode', 'id', 'inherited_admins',
'publishing_time', 'delivery_types',
'is_published', 'publishing_time_offset_from_now',
'scale_points_percent', 'deadline_handling',
'first_deadline', 'breadcrumb', 'anonymous',
'number_of_deliveries', 'number_of_groups',
'number_of_candidates',
'number_of_groups_where_is_examiner',
'has_valid_grading_setup', 'gradingsystemplugin_title',
'max_points', 'points_to_grade_mapper', 'grading_system_plugin_id', 'passing_grade_min_points'
]))
def test_get_admins(self):
self.client.login(username='******', password='******')
content, response = self.client.rest_get(self._geturl(self.testhelper.duck2000_someperiod_first.id))
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content['admins']), 1)
self.assertEquals(content['admins'][0]['email'], '*****@*****.**')
self.assertEquals(set(content['admins'][0].keys()),
set(['email', 'username', 'id', 'full_name']))
def test_get_inherited_admins(self):
self.client.login(username='******', password='******')
content, response = self.client.rest_get(self._geturl(self.testhelper.duck2000_someperiod_first.id))
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content['inherited_admins']), 2)
self.assertEquals(set(content['inherited_admins'][0].keys()),
set(['basenode', 'user']))
self.assertEquals(set(content['inherited_admins'][0]['basenode'].keys()),
set(['type', 'path', 'id', 'is_admin']))
self.assertEquals(set(content['inherited_admins'][0]['user'].keys()),
set(['email', 'username', 'id', 'full_name']))
inherited_adminusernames = [user['user']['username'] for user in content['inherited_admins']]
self.assertIn('uniadmin', inherited_adminusernames)
self.assertIn('duck2000admin', inherited_adminusernames)
def test_get_breadcrumb_assignmentadmin(self):
self.testhelper.add(nodes='uni.inf',
subjects=['sub'],
periods=['p1'],
assignments=['a1:admin(a1admin)'])
self.client.login(username='******', password='******')
content, response = self.client.rest_get(self._geturl(self.testhelper.sub_p1_a1.id))
self.assertEquals(response.status_code, 200)
th = self.testhelper
self.assertEquals(content['breadcrumb'],
[{u'id': th.sub_p1_a1.id, u'text': u'sub.p1.a1', u'type': u'Assignment'}])
def test_get_breadcrumb_periodadmin(self):
self.testhelper.add(nodes='uni.inf',
subjects=['sub'],
periods=['p1:admin(p1admin)'],
assignments=['a1'])
self.client.login(username='******', password='******')
content, response = self.client.rest_get(self._geturl(self.testhelper.sub_p1_a1.id))
self.assertEquals(response.status_code, 200)
th = self.testhelper
self.assertEquals(content['breadcrumb'],
[{u'id': th.sub_p1.id, u'text': u'sub.p1', u'type': u'Period'},
{u'id': th.sub_p1_a1.id, u'text': u'a1', u'type': u'Assignment'}])
def test_get_breadcrumb_subjectadmin(self):
self.testhelper.add(nodes='uni.inf',
subjects=['sub:admin(subadm)'],
periods=['p1'],
assignments=['a1'])
self.client.login(username='******', password='******')
content, response = self.client.rest_get(self._geturl(self.testhelper.sub_p1_a1.id))
self.assertEquals(response.status_code, 200)
th = self.testhelper
self.assertEquals(content['breadcrumb'],
[{u'id': th.sub.id, u'text': u'sub', u'type': u'Subject'},
{u'id': th.sub_p1.id, u'text': u'p1', u'type': u'Period'},
{u'id': th.sub_p1_a1.id, u'text': u'a1', u'type': u'Assignment'}])
def test_get_breadcrumb_nodeadmin(self):
self.testhelper.add(nodes='uni:admin(uniadm).inf',
subjects=['sub'],
periods=['p1'],
assignments=['a1'])
self.client.login(username='******', password='******')
content, response = self.client.rest_get(self._geturl(self.testhelper.sub_p1_a1.id))
self.assertEquals(response.status_code, 200)
th = self.testhelper
self.assertEquals(content['breadcrumb'],
[{u'id': th.uni.id, u'text': u'uni', u'type': u'Node'},
{u'id': th.uni_inf.id, u'text': u'inf', u'type': u'Node'},
{u'id': th.sub.id, u'text': u'sub', u'type': u'Subject'},
{u'id': th.sub_p1.id, u'text': u'p1', u'type': u'Period'},
{u'id': th.sub_p1_a1.id, u'text': u'a1', u'type': u'Assignment'}])
def test_get_breadcrumb_superuser(self):
self.testhelper.add(nodes='uni.inf',
subjects=['sub'],
periods=['p1'],
assignments=['a1'])
self.testhelper.create_superuser('super')
self.client.login(username='******', password='******')
content, response = self.client.rest_get(self._geturl(self.testhelper.sub_p1_a1.id))
self.assertEquals(response.status_code, 200)
th = self.testhelper
self.assertEquals(content['breadcrumb'],
[{u'id': th.uni.id, u'text': u'uni', u'type': u'Node'},
{u'id': th.uni_inf.id, u'text': u'inf', u'type': u'Node'},
{u'id': th.sub.id, u'text': u'sub', u'type': u'Subject'},
{u'id': th.sub_p1.id, u'text': u'p1', u'type': u'Period'},
{u'id': th.sub_p1_a1.id, u'text': u'a1', u'type': u'Assignment'}])
def test_get_can_not_delete(self):
self.client.login(username='******', password='******')
content, response = self.client.rest_get(self._geturl(self.testhelper.duck2000_someperiod_first.id))
self.assertEquals(response.status_code, 200)
self.assertFalse(content['can_delete'])
def test_put(self):
self.client.login(username='******', password='******')
data = {'short_name': 'duck2000',
'long_name': 'Updated',
'admins': [],
'publishing_time': isoformat_relativetime(days=-2),
'scale_points_percent': 80,
'deadline_handling': 0,
'delivery_types': 0,
'parentnode': 1}
content, response = self.client.rest_put(self._geturl(self.testhelper.duck2000_someperiod_first.id),
data=data)
self.assertEquals(response.status_code, 200)
self.assertEquals(content['id'], self.testhelper.duck2000_someperiod_first.id)
self.assertEquals(content['short_name'], self.testhelper.duck2000.short_name)
self.assertEquals(content['long_name'], 'Updated')
self.assertEquals(content['parentnode'], 1)
self.assertEquals(content['scale_points_percent'], 80)
self.assertEquals(content['deadline_handling'], 0)
self.assertEquals(content['delivery_types'], 0)
self.assertEquals(set(content.keys()),
set(['short_name', 'long_name', 'admins', 'etag',
'can_delete', 'parentnode', 'id', 'inherited_admins',
'publishing_time', 'delivery_types',
'is_published', 'publishing_time_offset_from_now',
'scale_points_percent', 'deadline_handling',
'first_deadline', 'breadcrumb', 'anonymous',
'number_of_deliveries', 'number_of_groups',
'number_of_candidates',
'number_of_groups_where_is_examiner',
'has_valid_grading_setup', 'gradingsystemplugin_title',
'max_points', 'points_to_grade_mapper', 'grading_system_plugin_id', 'passing_grade_min_points'
]))
updated = Assignment.objects.get(id=self.testhelper.duck2000_someperiod_first.id)
self.assertEquals(updated.long_name, 'Updated')
def test_put_admins(self):
self.client.login(username='******', password='******')
self.testhelper.create_user('user1')
self.testhelper.create_user('user2')
self.testhelper.create_user('user3')
data = {'short_name': 'duck2000',
'long_name': 'Updated',
'admins': [{'username': '******',
'email': 'ignored',
'full_name': 'ignored!'},
{'username': '******'},
{'id': self.testhelper.user3.id}],
'publishing_time': isoformat_relativetime(days=-2),
'scale_points_percent': 80,
'deadline_handling': 0,
'delivery_types': 0,
'parentnode': 1}
content, response = self.client.rest_put(self._geturl(self.testhelper.duck2000_someperiod_first.id),
data=data)
self.assertEquals(response.status_code, 200)
admins = content['admins']
self.assertEquals(len(content['admins']), 3)
admins.sort(cmp=lambda a,b: cmp(a['username'], b['username']))
self.assertEquals(admins[0]['username'], 'user1')
self.assertEquals(admins[2]['username'], 'user3')
updated = Assignment.objects.get(id=self.testhelper.duck2000_someperiod_first.id)
self.assertEquals(updated.admins.all().count(), 3)
class TestCreateGroupRest(TestCase, GroupManagerTestMixin):
def setUp(self):
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['p1'],
assignments=['a1:admin(a1admin)'])
self.client = RestClient()
self.testhelper.create_user('candidate1')
self.testhelper.create_user('examiner1')
self.testhelper.create_superuser('grandma')
self.a1id = self.testhelper.sub_p1_a1.id
def _geturl(self, assignment_id):
return '/devilry_subjectadmin/rest/group/{0}/'.format(assignment_id)
def _postas(self, username, assignment_id, data={}):
self.client.login(username=username, password='******')
return self.client.rest_post(self._geturl(assignment_id), data)
def test_create_minimal(self):
data = {'name': 'g1',
'is_open': False}
content, response = self._postas('a1admin', self.a1id, data)
self.assertEquals(response.status_code, 201)
self.assertEquals(set(content.keys()),
set(['name', 'id', 'etag', 'is_open', 'parentnode',
'feedback', 'deadlines', 'candidates', 'tags',
'examiners', 'num_deliveries']))
self.assertEquals(content['name'], 'g1')
self.assertEquals(content['is_open'], False)
self.assertEquals(content['parentnode'], self.a1id)
self.assertEquals(content['num_deliveries'], 0)
self.assertEquals(content['feedback'], None)
self.assertEquals(content['deadlines'], [])
self.assertEquals(content['candidates'], [])
self.assertEquals(content['examiners'], [])
self.assertEquals(content['tags'], [])
groups = self.testhelper.sub_p1_a1.assignmentgroups.all()
self.assertEquals(len(groups), 1)
self.assertEquals(content['id'], groups[0].id)
def _test_create_as(self, username):
data = {'name': 'g1',
'is_open': False,
'examiners': [self.create_examinerdict(username='******')],
'candidates': [self.create_candidatedict(username='******')],
'tags': [self.create_tagdict('mytag')]}
content, response = self._postas(username, self.a1id, data)
#from pprint import pprint
#print 'Response content:'
#pprint(content)
self.assertEquals(response.status_code, 201)
self.assertEquals(content['name'], 'g1')
self.assertEquals(content['is_open'], False)
self.assertEquals(content['parentnode'], self.a1id)
self.assertEquals(content['num_deliveries'], 0)
# Feedback
self.assertEquals(content['feedback'], None)
# Deadlines
self.assertEquals(content['deadlines'], [])
# Tags
self.assertEquals(len(content['tags']), 1)
tag = content['tags'][0]
self.assertEquals(tag['tag'], 'mytag')
self.assertEquals(set(tag.keys()), set(['id', 'tag']))
# Examiners
self.assertEquals(len(content['examiners']), 1)
examiner = content['examiners'][0]
self.assertEquals(set(examiner.keys()),
set(['id', 'user']))
self.assertEquals(set(examiner['user'].keys()),
set(['email', 'full_name', 'id', 'username']))
self.assertEquals(examiner['user']['id'], self.testhelper.examiner1.id)
self.assertEquals(examiner['user']['username'], 'examiner1')
# Candidates
self.assertEquals(len(content['candidates']), 1)
candidate = content['candidates'][0]
self.assertEquals(set(candidate.keys()),
set(['id', 'user', 'candidate_id']))
self.assertEquals(set(candidate['user'].keys()),
set(['email', 'full_name', 'id', 'username']))
self.assertEquals(candidate['user']['id'], self.testhelper.candidate1.id)
self.assertEquals(candidate['candidate_id'], '')
self.assertEquals(candidate['user']['username'], 'candidate1')
# It was actually created?
groups = self.testhelper.sub_p1_a1.assignmentgroups.all()
self.assertEquals(len(groups), 1)
self.assertEquals(content['id'], groups[0].id)
def test_create_as_assignmentadmin(self):
self._test_create_as('a1admin')
def test_create_as_superuser(self):
self._test_create_as('grandma')
def test_noperm(self):
self.testhelper.create_user('nobody')
data = {'name': 'g1',
'is_open': False}
content, response = self._postas('nobody', self.a1id, data)
self.assertEquals(response.status_code, 403)
self.assertEquals(content, {u'detail': u'Permission denied'})
def test_create_ro_fields(self):
data = {'name': 'g1',
'is_open': False,
'id': 'should be ignored',
'feedback': 'should be ignored',
'num_deliveries': 'should be ignored',
'deadlines': 'should be ignored'}
content, response = self._postas('a1admin', self.a1id, data)
self.assertEquals(response.status_code, 201)
class TestInstanceGroupRest(TestCase, GroupManagerTestMixin):
def setUp(self):
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['p1'],
assignments=['a1:admin(a1admin)'])
self.client = RestClient()
self.testhelper.create_superuser('grandma')
self.testhelper.create_user('candidate1')
self.testhelper.create_user('examiner1')
self.testhelper.create_superuser('superuser')
self.a1id = self.testhelper.sub_p1_a1.id
def _geturl(self, assignment_id, group_id):
return '/devilry_subjectadmin/rest/group/{0}/{1}'.format(assignment_id, group_id)
def _putas(self, username, assignment_id, group_id, data={}):
self.client.login(username=username, password='******')
return self.client.rest_put(self._geturl(assignment_id, group_id), data)
def _add_group(self, name, candidates, examiners):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate({candidates}):examiner({examiners})'.format(**vars()))
return getattr(self.testhelper, 'sub_p1_a1_' + name)
def test_put_minimal(self):
group = self._add_group('g1', candidates='candidate1', examiners='examiner1')
self.assertEquals(group.name, 'g1')
self.assertEquals(group.is_open, True)
data = {'name': 'changed',
'is_open': False}
content, response = self._putas('a1admin', self.a1id, group.id, data)
self.assertEquals(response.status_code, 200)
self.assertEquals(set(content.keys()),
set(['name', 'id', 'etag', 'is_open', 'parentnode',
'feedback', 'deadlines', 'candidates', 'tags',
'examiners', 'num_deliveries']))
self.assertEquals(content['name'], 'changed')
self.assertEquals(content['is_open'], False)
self.assertEquals(content['parentnode'], self.a1id)
self.assertEquals(content['num_deliveries'], 0)
self.assertEquals(content['feedback'], None)
self.assertEquals(content['deadlines'], [])
self.assertEquals(content['candidates'], [])
self.assertEquals(content['examiners'], [])
self.assertEquals(content['tags'], [])
groups = self.testhelper.sub_p1_a1.assignmentgroups.all()
self.assertEquals(len(groups), 1)
self.assertEquals(content['id'], groups[0].id)
def _test_put_as(self, username):
group = self._add_group('g1', candidates='candidate2', examiners='examiner2')
data = {'name': 'changed',
'is_open': False,
'examiners': [self.create_examinerdict(username='******')],
'candidates': [self.create_candidatedict(username='******')],
'tags': [self.create_tagdict('mytag')]}
content, response = self._putas(username, self.a1id, group.id, data)
#from pprint import pprint
#print 'Response content:'
#pprint(content)
self.assertEquals(response.status_code, 200)
self.assertEquals(content['name'], 'changed')
self.assertEquals(content['is_open'], False)
self.assertEquals(content['parentnode'], self.a1id)
self.assertEquals(content['num_deliveries'], 0)
# Feedback
self.assertEquals(content['feedback'], None)
# Deadlines
self.assertEquals(content['deadlines'], [])
# Tags
self.assertEquals(len(content['tags']), 1)
tag = content['tags'][0]
self.assertEquals(tag['tag'], 'mytag')
self.assertEquals(set(tag.keys()), set(['id', 'tag']))
# Examiners
self.assertEquals(len(content['examiners']), 1)
examiner = content['examiners'][0]
self.assertEquals(set(examiner.keys()),
set(['id', 'user']))
self.assertEquals(set(examiner['user'].keys()),
set(['email', 'full_name', 'id', 'username']))
self.assertEquals(examiner['user']['id'], self.testhelper.examiner1.id)
self.assertEquals(examiner['user']['username'], 'examiner1')
# Candidates
self.assertEquals(len(content['candidates']), 1)
candidate = content['candidates'][0]
self.assertEquals(set(candidate.keys()),
set(['id', 'user', 'candidate_id']))
self.assertEquals(set(candidate['user'].keys()),
set(['email', 'full_name', 'id', 'username']))
self.assertEquals(candidate['user']['id'], self.testhelper.candidate1.id)
self.assertEquals(candidate['candidate_id'], '')
self.assertEquals(candidate['user']['username'], 'candidate1')
# It was actually updated?
group = self.testhelper.sub_p1_a1.assignmentgroups.get(id=group.id)
self.assertEquals(group.name, 'changed')
def test_put_as_superuser(self):
self._test_put_as('superuser')
def test_put_as_assignmentadmin(self):
self._test_put_as('a1admin')
def test_put_doesnotexist(self):
data = {'name': 'changed',
'is_open': False}
content, response = self._putas('grandma', 10000, 100000, data)
self.assertEquals(response.status_code, 404)
def test_put_denied(self):
self.testhelper.create_user('nobody')
self.testhelper.add_to_path('uni;sub.p1.a1.g1')
group = self.testhelper.sub_p1_a1_g1
data = {'name': 'changed',
'is_open': False}
content, response = self._putas('nobody', self.a1id, group.id, data)
self.assertEquals(response.status_code, 403)
def test_put_ro_fields(self):
group = self._add_group('g1', candidates='candidate1', examiners='examiner1')
self.assertEquals(group.name, 'g1')
self.assertEquals(group.is_open, True)
data = {'name': 'changed',
'is_open': False,
'feedback': 'should be ignored',
'id': 'should be ignored',
'num_deliveries': 'should be ignored',
'deadlines': 'should be ignored'}
content, response = self._putas('a1admin', self.a1id, group.id, data)
self.assertEquals(response.status_code, 200)
#
# GET
#
def _getas(self, username, assignment_id, group_id):
self.client.login(username=username, password='******')
return self.client.rest_get(self._geturl(assignment_id, group_id))
def _test_get_as(self, username):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(candidate1):examiner(examiner1).d1:ends(5)')
self.testhelper.add_to_path('uni;sub.p1.a1.g1.d2:ends(10)')
group = self.testhelper.sub_p1_a1_g1
content, response = self._getas(username, self.a1id, group.id)
#from pprint import pprint
#print 'Response content:'
#pprint(content)
self.assertEquals(response.status_code, 200)
self.assertEquals(set(content.keys()),
set(['name', 'id', 'etag', 'is_open', 'parentnode',
'feedback', 'deadlines', 'candidates', 'tags',
'examiners', 'num_deliveries']))
self.assertEquals(content['name'], 'g1')
self.assertEquals(content['is_open'], True)
self.assertEquals(content['parentnode'], self.a1id)
self.assertEquals(content['num_deliveries'], 0)
self.assertEquals(content['feedback'], None)
# Deadlines
self.assertEquals(len(content['deadlines']), 2)
self.assertEquals(set(content['deadlines'][0].keys()),
set(['id', 'deadline']))
# Candidates
self.assertEquals(len(content['candidates']), 1)
candidate = content['candidates'][0]
self.assertEquals(candidate['candidate_id'], None)
self.assertEquals(candidate['user'], {'id': self.testhelper.candidate1.id,
'username': '******',
'email': '*****@*****.**',
'full_name': None})
# Examiners
self.assertEquals(len(content['examiners']), 1)
examiner = content['examiners'][0]
self.assertEquals(examiner['user'], {'id': self.testhelper.examiner1.id,
'username': '******',
'email': '*****@*****.**',
'full_name': None})
def test_get_as_assignmentadmin(self):
self._test_get_as('a1admin')
def test_get_as_superuser(self):
self._test_get_as('superuser')
def test_get_denied(self):
self.testhelper.create_user('nobody')
self.testhelper.add_to_path('uni;sub.p1.a1.g1')
group = self.testhelper.sub_p1_a1_g1
content, response = self._getas('nobody', self.a1id, group.id)
self.assertEquals(response.status_code, 403)
class TestRestPassedInPreviousPeriod(TransactionTestCase):
def setUp(self):
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['old:begins(-14):ends(6)', # 14 months ago
'cur:begins(-2)'], # 2 months ago
assignments=['a1:admin(adm):pub(0)']) # 0 days after period begins
self.client = RestClient()
self.url = '/devilry_subjectadmin/rest/passedinpreviousperiod/{0}'.format(self.testhelper.sub_cur_a1.id)
def _getas(self, username, **data):
self.client.login(username=username, password='******')
return self.client.rest_get(self.url, **data)
def _test_get_simple_as(self, username):
self.testhelper.add_to_path('uni;sub.cur.a1.g1:candidate(student1)')
content, response = self._getas(username)
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 1)
item = content[0]
self.assertEquals(item['group']['id'], self.testhelper.sub_cur_a1_g1.id)
self.assertEquals(item['oldgroup'], None)
self.assertEquals(item['whyignored'], 'not_in_previous')
def test_get_simple_as_assignmentadmin(self):
self._test_get_simple_as('adm')
def test_get_simple_as_superuser(self):
self.testhelper.create_superuser('super')
self._test_get_simple_as('super')
def test_get_as_nobody(self):
self.testhelper.create_user('nobody')
content, response = self._getas('nobody')
self.assertEquals(response.status_code, 403)
def test_with_oldfeedback(self):
# Add a group for the student on the old period
self.testhelper.add_to_path('uni;sub.old.a1.g1:candidate(student1):examiner(examiner1).d1:ends(1)')
self.testhelper.create_feedbacks(
(self.testhelper.sub_old_a1_g1, {'grade': 'approved', 'points': 1, 'is_passing_grade': True})
)
# Add the student to the current period
self.testhelper.add_to_path('uni;sub.cur.a1.g1:candidate(student1)')
content, response = self._getas('adm')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 1)
item = content[0]
self.assertEquals(item['group']['id'], self.testhelper.sub_cur_a1_g1.id)
self.assertEquals(item['whyignored'], None)
self.assertNotEquals(item['oldgroup'], None)
oldgroup = item['oldgroup']
self.assertEqual(oldgroup['id'], self.testhelper.sub_old_a1_g1.id)
self.assertEqual(oldgroup['assignment']['id'], self.testhelper.sub_old_a1.id)
self.assertEqual(oldgroup['period']['id'], self.testhelper.sub_old.id)
self.assertEqual(oldgroup['feedback_shortformat'], 'true')
def _putas(self, username, data):
self.client.login(username=username, password='******')
return self.client.rest_put(self.url, data)
def _test_putas(self, username):
self.testhelper.add_to_path('uni;sub.cur.a1.g1:candidate(student1).d1')
self.testhelper.add_to_path('uni;sub.cur.a1.g2:candidate(student2).d1')
self.testhelper.add_to_path('uni;sub.cur.a1.g3:candidate(student3).d1')
self.testhelper.add_to_path('uni;sub.old.a1.g3:candidate(student3):examiner(examiner1).d1')
oldg3_delivery = self.testhelper.add_delivery(self.testhelper.sub_old_a1_g3)
self.testhelper.add_feedback(oldg3_delivery,
verdict=dict(grade='C', points=40,
is_passing_grade=True))
g1 = self.testhelper.sub_cur_a1_g1
g2 = self.testhelper.sub_cur_a1_g2
g3 = self.testhelper.sub_cur_a1_g3
content, response = self._putas(username,
[{'id': g1.id,
'newfeedback_shortformat': 'true'},
{'id': g3.id,
'newfeedback_shortformat': 'true'}])
self.assertEquals(response.status_code, 200)
g1 = self.testhelper.reload_from_db(g1)
self.assertEquals(g1.feedback.grade, 'approved')
self.assertEquals(g1.feedback.delivery.delivery_type, deliverytypes.ALIAS)
g2 = self.testhelper.reload_from_db(g2)
self.assertEquals(g2.feedback, None)
g3 = self.testhelper.reload_from_db(g3)
self.assertEquals(g3.feedback.grade, 'approved')
self.assertEquals(g3.feedback.delivery.delivery_type, deliverytypes.ALIAS)
self.assertEquals(g3.feedback.delivery.alias_delivery, oldg3_delivery)
def test_put_as_assignmentadmin(self):
self._test_putas('adm')
def test_put_as_superuser(self):
self.testhelper.create_superuser('super')
self._test_putas('super')
def test_put_as_nobody(self):
self.testhelper.create_user('nobody')
content, response = self._putas('nobody', [])
self.assertEquals(response.status_code, 403)
def test_put_shortformat_validationerror(self):
self.testhelper.add_to_path('uni;sub.cur.a1.g1:candidate(student1).d1')
g1 = self.testhelper.sub_cur_a1_g1
content, response = self._putas('adm',
[{'id': g1.id,
'newfeedback_shortformat': 'invalidstuff'}])
self.assertEquals(response.status_code, 400)
self.assertEquals(content['errors'][0], u'Must be one of: true, false.')
class TestListGroupRest(TestCase):
def setUp(self):
self.testhelper = TestHelper()
self.client = RestClient()
def _geturl(self, assignment_id):
assignment_id = assignment_id or self.testhelper.sub_p1_a1.id
return '/devilry_subjectadmin/rest/group/{0}/'.format(assignment_id)
def _getas(self, username, assignment_id, **data):
self.client.login(username=username, password='******')
return self.client.rest_get(self._geturl(assignment_id), **data)
def _create_testassignments(self):
self.testhelper.add(nodes='uni',
subjects=['duck1010'],
periods=['firstsem'],
assignments=['a1:admin(a1admin)', 'a2'])
def _create_testdata(self):
self._create_testassignments()
for num in xrange(3):
path = 'uni;duck1010.firstsem.a1.g{num}:candidate(student{num},extrastudent):examiner(examiner1,extraexaminer).d1'
self.testhelper.add_to_path(path.format(**vars()))
group = getattr(self.testhelper, 'duck1010_firstsem_a1_g{0}'.format(num))
group.tags.create(tag="stuff")
group.tags.create(tag="lownumber")
delivery = self.testhelper.add_delivery(group)
if num != 2:
self.testhelper.add_feedback(delivery,
verdict=dict(grade='A', points=100,
is_passing_grade=True))
def test_list_permissiondenied(self):
self.testhelper.create_user('nobody')
self._create_testassignments()
a1 = self.testhelper.duck1010_firstsem_a1
content, response = self._getas('nobody', a1.id)
self.assertEquals(response.status_code, 403)
def _test_list_as(self, username):
self._create_testdata()
a1 = self.testhelper.duck1010_firstsem_a1
content, response = self._getas(username, a1.id)
#from pprint import pprint
#pprint(content)
self.assertEquals(len(content), 3)
self.assertEquals(set(content[0].keys()),
set(['name', 'feedback', 'deadlines', 'id', 'etag',
'is_open', 'parentnode', 'candidates', 'tags',
'examiners', 'num_deliveries']))
# Properties directly from group
self.assertEquals(AssignmentGroup.objects.get(id=content[0]['id']).parentnode_id,
a1.id)
self.assertEquals(content[0]['is_open'], False)
self.assertEquals(content[0]['name'], 'g0')
self.assertEquals(content[0]['num_deliveries'], 1)
self.assertEquals(content[0]['parentnode'], a1.id)
# Feedback
feedback = content[0]['feedback']
self.assertEquals(set(feedback.keys()),
set(['id', 'grade', 'is_passing_grade', 'points', 'save_timestamp']))
self.assertEquals(feedback['grade'], 'A')
self.assertEquals(feedback['is_passing_grade'], True)
self.assertEquals(feedback['points'], 100)
# NULL feedback
self.assertEquals(content[2]['feedback'], None)
# Canididates
def get_usernames(users):
return [user['user']['username'] for user in users]
self.assertEquals(len(content[0]['candidates']), 2)
self.assertEquals(set(get_usernames(content[0]['candidates'])),
set(['student0', 'extrastudent']))
self.assertEquals(set(content[0]['candidates'][0].keys()),
set(['id', 'candidate_id', 'user']))
self.assertEquals(set(content[0]['candidates'][0]['user'].keys()),
set(['email', 'full_name', 'id', 'username']))
# Examiners
self.assertEquals(len(content[0]['examiners']), 2)
self.assertEquals(set(get_usernames(content[0]['examiners'])),
set(['examiner1', 'extraexaminer']))
self.assertEquals(set(content[0]['examiners'][0].keys()),
set(['id', 'user']))
self.assertEquals(set(content[0]['examiners'][0]['user'].keys()),
set(['email', 'full_name', 'id', 'username']))
# Deadlines
self.assertEquals(len(content[0]['deadlines']), 1)
deadline = content[0]['deadlines'][0]
self.assertEquals(set(deadline.keys()),
set(['id', 'deadline']))
# Tags
self.assertEquals(len(content[0]['tags']), 2)
tag = content[0]['tags'][0]
self.assertEquals(set(tag.keys()),
set(['id', 'tag']))
def test_list(self):
self._test_list_as('a1admin')
def test_list_as_superuser(self):
self.testhelper.create_superuser('superuser')
self._test_list_as('superuser')
class TestListRelatedUserOnAssignmentMixin(object):
def setUp(self):
self.client = RestClient()
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['p1'],
assignments=['a1:admin(a1admin)',
'a2:admin(a2admin)'])
self.testhelper.add_to_path('uni;sub.p2')
self.testhelper.create_superuser("superuser")
self.testhelper.create_user('testuser')
def get_url(self):
"""
Get url of rest API.
"""
raise NotImplementedError()
def _listas(self, username, **data):
self.client.login(username=username, password='******')
return self.client.rest_get(self.get_url(), **data)
def _create_user(self, index):
username = "******".format(index)
user = self.testhelper.create_user(username)
user.email = username + '@example.com'
user.devilryuserprofile.full_name = 'User {0}'.format(index)
user.save()
user.devilryuserprofile.save()
return user
def create_relateduser(self, period, index, tags=''):
"""
Create a related user of the type that we are testing.
"""
raise NotImplementedError()
def _create_relatedusers(self, count):
for index in xrange(count):
self.create_relateduser(self.testhelper.sub_p1, index)
def test_list(self):
self._create_relatedusers(2)
self.create_relateduser(self.testhelper.sub_p1, index=5, tags='group1,group2')
self.create_relateduser(self.testhelper.sub_p2, index=20, tags='') # Not on p1, so we shold not get this in the listing!
content, response = self._listas(self.testhelper.a1admin, period=self.testhelper.sub_p1.id)
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 3) # Since this is 3, we did not get the user registered on p2.
first, second, last = content
self.assertEquals(first['user']['username'], 'reluser0')
self.assertEquals(first['user']['full_name'] , 'User 0')
self.assertEquals(first['tags'], '')
self.assertEquals(second['tags'], '')
self.assertEquals(second['user']['username'], 'reluser1')
self.assertEquals(last['user']['username'], 'reluser5')
self.assertEquals(last['tags'], 'group1,group2')
return content
def test_list_none(self):
content, response = self._listas(self.testhelper.a1admin, period=self.testhelper.sub_p1.id)
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 0)
def test_list_superuser(self):
self._create_relatedusers(2)
content, response = self._listas(self.testhelper.superuser, period=self.testhelper.sub_p1.id)
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 2)
def test_list_not_admin(self):
self._create_relatedusers(2)
content, response = self._listas(self.testhelper.a2admin, period=self.testhelper.sub_p1.id)
self.assertEquals(response.status_code, 403)
class TestRestMergeIntoGroup(TestCase):
def setUp(self):
self.client = RestClient()
self.testhelper = TestHelper()
self.testhelper.add(
nodes="uni", subjects=["sub"], periods=["p1:begins(-2)"], assignments=["a1:admin(a1admin)"] # 2 months ago
)
self.assignment = self.testhelper.sub_p1_a1
self.url = "/devilry_subjectadmin/rest/mergeintogroup/{0}".format(self.assignment.id)
def _postas(self, username, data):
self.client.login(username=username, password="******")
return self.client.rest_post(self.url, data)
def test_post(self):
self.testhelper.add_to_path("uni;sub.p1.a1.g1:candidate(student1,student2):examiner(examiner1).d1")
self.testhelper.add_delivery("sub.p1.a1.g1", {"bad.py": ["print ", "bah"]})
self.testhelper.add_feedback("sub.p1.a1.g1", verdict={"grade": "F", "points": 30, "is_passing_grade": False})
source = self.testhelper.sub_p1_a1_g1
self.testhelper.add_to_path("uni;sub.p1.a1.g2:candidate(student1,student3):examiner(examiner2)")
target = self.testhelper.sub_p1_a1_g2
self.assertEquals(self.assignment.assignmentgroups.count(), 2)
content, response = self._postas(
"a1admin", {"source_group_ids": [{"id": source.id}], "target_group_id": target.id}
)
self.assertEquals(response.status_code, 200)
self.assertEquals(content["success"], True)
self.assertEquals(content["target_group_id"], target.id)
self.assertEquals(content["source_group_ids"], [{"id": source.id}])
self.assertEquals(self.assignment.assignmentgroups.count(), 1)
merged_target = self.assignment.assignmentgroups.all()[0]
self.assertEquals(merged_target.candidates.count(), 3)
self.assertEquals(merged_target.examiners.count(), 2)
def test_post_multiple(self):
self.testhelper.add_to_path("uni;sub.p1.a1.source1:candidate(student1,student2):examiner(examiner1).d1")
self.testhelper.add_to_path("uni;sub.p1.a1.source2:candidate(student1,student2)")
self.testhelper.add_to_path("uni;sub.p1.a1.source3:candidate(student1)")
self.testhelper.add_to_path("uni;sub.p1.a1.source4:candidate(student6)")
source_group_ids = []
for num in xrange(1, 5):
group = getattr(self.testhelper, "sub_p1_a1_source{0}".format(num))
source_group_ids.append({"id": group.id})
self.assertEquals(len(source_group_ids), 4)
self.testhelper.add_to_path("uni;sub.p1.a1.g2:candidate(student1,student3):examiner(examiner2)")
target = self.testhelper.sub_p1_a1_g2
self.assertEquals(self.assignment.assignmentgroups.count(), 5)
content, response = self._postas(
"a1admin", {"source_group_ids": source_group_ids, "target_group_id": target.id}
)
self.assertEquals(response.status_code, 200)
self.assertEquals(content["success"], True)
self.assertEquals(content["target_group_id"], target.id)
self.assertEquals(content["source_group_ids"], source_group_ids)
self.assertEquals(self.assignment.assignmentgroups.count(), 1)
merged_target = self.assignment.assignmentgroups.all()[0]
self.assertEquals(merged_target.candidates.count(), 4)
self.assertEquals(merged_target.examiners.count(), 2)
def test_post_nobody(self):
self.testhelper.create_user("nobody")
content, response = self._postas("nobody", {"source_group_ids": [{"id": 1}], "target_group_id": 1})
self.assertEquals(response.status_code, 403)
def test_post_not_found(self):
content, response = self._postas(
"a1admin", {"source_group_ids": [{"id": 10000000}], "target_group_id": 1100000}
)
self.assertEquals(response.status_code, 404)
class TestRestDeadlinesBulkUpdateReadOrDelete(TestCase):
def setUp(self):
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['p1:begins(-2)']) # 2 months ago
self.testhelper.sub_p1.start_time = datetime(2000, 1, 1, 22, 30, 49)
self.testhelper.sub_p1.save()
self.testhelper.add_to_path('uni;sub.p1.a1:admin(adm):pub(0)') # 0 days after period begins + 2 sec
self.client = RestClient()
for groupnum in xrange(3):
# deadline 5 days after assignment starts
self.testhelper.add_to_path('uni;sub.p1.a1.g{0}:candidate(cand1):examiner(exam1).d1:ends(5)'.format(groupnum))
def _geturl(self, deadline=None):
deadline = deadline or self.testhelper.sub_p1_a1_g1_d1
bulkdeadline_id = encode_bulkdeadline_id(deadline)
return '/devilry_subjectadmin/rest/deadlinesbulk/{0}/{1}'.format(self.testhelper.sub_p1_a1.id,
bulkdeadline_id)
def test_encode_unique_bulkdeadline_id(self):
d = Deadline(deadline=datetime(2000, 12, 24, 22, 30, 49))
self.assertEquals(encode_bulkdeadline_id(d),
'2000-12-24T22_30_49--')
d.text = 'Hello world'
self.assertEquals(encode_bulkdeadline_id(d),
'2000-12-24T22_30_49--{0}'.format(sha1hash('Hello world')))
# Ensure unicode works
d.text = u'\u00e5ello world'
self.assertEquals(encode_bulkdeadline_id(d),
'2000-12-24T22_30_49--{0}'.format(sha1hash(u'\u00e5ello world')))
def test_decode_unique_bulkdeadline_id(self):
self.assertEquals(decode_bulkdeadline_id('2000-12-24T22_30_49--'),
(datetime(2000, 12, 24, 22, 30, 49), ''))
self.assertEquals(decode_bulkdeadline_id('2000-12-24T22_30_49--{0}'.format(sha1hash('Hello world'))),
(datetime(2000, 12, 24, 22, 30, 49), sha1hash('Hello world')))
def _putas(self, username, data):
self.client.login(username=username, password='******')
return self.client.rest_put(self._geturl(), data)
def test_put(self):
self.assertEquals(self.testhelper.sub_p1_a1.publishing_time, datetime(2000, 1, 1, 22, 30, 51))
self.assertEquals(self.testhelper.sub_p1_a1_g1_d1.deadline,
datetime(2000, 1, 1, 22, 30) + timedelta(days=5))
new_deadline = datetime(2004, 12, 24, 20, 30)
content, response = self._putas('adm', {'deadline': format_datetime(new_deadline),
'text': 'Hello'})
self.assertEquals(response.status_code, 200)
self.assertEquals(decode_bulkdeadline_id(content['bulkdeadline_id'])[0],
new_deadline)
self.assertEquals(len(content['groups']), 3)
self.assertEquals(content['text'], 'Hello')
self.assertEquals(content['deadline'], format_datetime(new_deadline))
for groupnum in xrange(3):
deadline_id = getattr(self.testhelper, 'sub_p1_a1_g{0}_d1'.format(groupnum)).id
deadline = Deadline.objects.get(id=deadline_id)
self.assertEquals(deadline.deadline, new_deadline)
self.assertEquals(deadline.text, 'Hello')
def test_put_nonetext(self):
self.assertEquals(self.testhelper.sub_p1_a1.publishing_time, datetime(2000, 1, 1, 22, 30, 51))
self.assertEquals(self.testhelper.sub_p1_a1_g1_d1.deadline,
datetime(2000, 1, 1, 22, 30) + timedelta(days=5))
new_deadline = datetime(2004, 12, 24, 20, 30)
content, response = self._putas('adm', {'deadline': format_datetime(new_deadline),
'text': None})
self.assertEquals(response.status_code, 200)
for groupnum in xrange(3):
deadline_id = getattr(self.testhelper, 'sub_p1_a1_g{0}_d1'.format(groupnum)).id
deadline = Deadline.objects.get(id=deadline_id)
self.assertEquals(deadline.deadline, new_deadline)
self.assertEquals(deadline.text, '')
def test_put_before_publishingtime(self):
new_deadline = datetime(1990, 1, 1, 20, 30, 40)
content, response = self._putas('adm', {'deadline': format_datetime(new_deadline),
'text': None})
self.assertEquals(response.status_code, 400)
self.assertEquals(content['errors'], ['Deadline cannot be before publishing time.'])
def test_put_nobody(self):
self.testhelper.create_user('nobody')
content, response = self._putas('nobody', {})
self.assertEquals(response.status_code, 403)
def test_put_with_bulkdeadline_id(self):
new_deadline = datetime(2004, 12, 24, 20, 30)
content, response = self._putas('adm', {'deadline': format_datetime(new_deadline),
'bulkdeadline_id': 'ignored'})
self.assertEquals(response.status_code, 200)
def test_put_group_ids(self):
new_deadline = datetime(2004, 12, 24, 20, 30)
g1 = self.testhelper.sub_p1_a1_g1
g2 = self.testhelper.sub_p1_a1_g2
self.assertEquals(g1.deadlines.count(), 1)
content, response = self._putas('adm', {'deadline': format_datetime(new_deadline),
'text': 'Updated',
'group_ids': [g1.id, g2.id]})
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content['groups']), 2)
group_ids = set([g['id'] for g in content['groups']])
self.assertEquals(group_ids, set([g1.id, g2.id]))
for group in g1, g2:
group = self.testhelper.reload_from_db(group)
self.assertEquals(group.deadlines.count(), 1)
deadline = group.deadlines.all()[0]
self.assertEquals(deadline.deadline, new_deadline)
self.assertEquals(deadline.text, 'Updated')
def _getas(self, username, **data):
self.client.login(username=username, password='******')
return self.client.rest_get(self._geturl(), **data)
def test_get(self):
content, response = self._getas('adm')
self.assertEquals(response.status_code, 200)
self.assertEquals(decode_bulkdeadline_id(content['bulkdeadline_id'])[0],
self.testhelper.sub_p1_a1_g1_d1.deadline)
self.assertEquals(content['deadline'],
format_datetime(self.testhelper.sub_p1_a1_g1_d1.deadline))
self.assertEquals(content['text'], None)
self.assertEquals(len(content['groups']), 3)
def test_get_nobody(self):
self.testhelper.create_user('nobody')
content, response = self._getas('nobody')
self.assertEquals(response.status_code, 403)
def _deleteas(self, username, deadline=None):
self.client.login(username=username, password='******')
return self.client.rest_delete(self._geturl(deadline))
def test_delete_sanity(self):
# Test that the deadline method actually does what it is supposed to do (only deletes what it should delete)
new_deadline = datetime(2004, 12, 24, 20, 30)
created_deadline = None
for groupnum in xrange(2):
group = getattr(self.testhelper, 'sub_p1_a1_g{0}'.format(groupnum))
self.assertEquals(1, group.deadlines.count())
created_deadline = group.deadlines.create(deadline=new_deadline) # NOTE: Does not matter which deadline object we user, since we only need the datetime and text to generate bulkdeadline_id
self.assertEquals(2, group.deadlines.count())
self.testhelper.sub_p1_a1_g2.deadlines.create(deadline=datetime(2006, 12, 24, 20, 30))
self.testhelper.create_superuser('superuser')
content, response = self._deleteas('superuser', deadline=created_deadline)
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content['deleted_deadline_ids']), 2)
self.assertEquals(1, self.testhelper.sub_p1_a1_g0.deadlines.count())
self.assertEquals(1, self.testhelper.sub_p1_a1_g1.deadlines.count())
self.assertEquals(2, self.testhelper.sub_p1_a1_g2.deadlines.count())
def test_delete_with_content_as_superuser(self):
self.testhelper.create_superuser('superuser')
self.testhelper.add_delivery('sub.p1.a1.g1', {'bad.py': ['print ', 'bah']})
self.testhelper.add_feedback('sub.p1.a1.g1', verdict={'grade': 'F', 'points': 30, 'is_passing_grade': False})
content, response = self._deleteas('superuser')
self.assertEquals(response.status_code, 200)
def test_delete_with_content_as_assignmentadm(self):
self.testhelper.add_delivery('sub.p1.a1.g1', {'bad.py': ['print ', 'bah']})
self.testhelper.add_feedback('sub.p1.a1.g1', verdict={'grade': 'F', 'points': 30, 'is_passing_grade': False})
content, response = self._deleteas('adm')
self.assertEquals(response.status_code, 403)
def test_delete_without_content_as_assignmentadm(self):
content, response = self._deleteas('adm')
self.assertEquals(response.status_code, 200)
def test_delete_as_nobody(self):
self.testhelper.create_user('nobody')
content, response = self._deleteas('nobody')
self.assertEquals(response.status_code, 403)
class TestRestOpenGroups(TestCase):
def setUp(self):
self.client = RestClient()
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['p0:begins(-10):ends(2)',
'p1:begins(-2):ends(6)',
'p2:begins(5)'],
assignments=['a1'])
self.testhelper.create_user('testuser')
self.url = '/devilry_student/rest/open-groups/'
def _getas(self, username, **data):
self.client.login(username=username, password='******')
return self.client.rest_get(self.url, **data)
def test_open_groups_empty(self):
content, response = self._getas('testuser')
self.assertEquals(response.status_code, 200)
self.assertEquals(content, [])
def test_open_groups(self):
# Add 3 to the active period, but close one of the groups
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1).d1')
self.testhelper.add_to_path('uni;sub.p1.a1.g2:candidate(student1).d1')
self.testhelper.add_to_path('uni;sub.p1.a1.g3:candidate(student1).d1')
self.testhelper.sub_p1_a1_g1.is_open = False
self.testhelper.sub_p1_a1_g1.save()
# Add to the past and the future periods (should not show up)
self.testhelper.add_to_path('uni;sub.p0.a1.gX:candidate(student1).d1')
self.testhelper.add_to_path('uni;sub.p2.a1.gY:candidate(student1).d1')
content, response = self._getas('student1')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 2)
groupnames = set([group['name'] for group in content])
self.assertEquals(groupnames, set(['g2', 'g3']))
def test_deadline_expired_and_order(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1).d1:ends(1)')
self.testhelper.add_to_path('uni;sub.p1.a1.g2:candidate(student1).d1:ends(70)')
content, response = self._getas('student1')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 2)
self.assertEquals(content[0]['name'], 'g1')
self.assertEquals(content[0]['active_deadline']['deadline_expired'], True)
self.assertEquals(content[1]['name'], 'g2')
self.assertEquals(content[1]['active_deadline']['deadline_expired'], False)
def test_only_deadline_expired(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1).d1:ends(1)')
self.testhelper.add_to_path('uni;sub.p1.a1.g2:candidate(student1).d1:ends(70)')
content, response = self._getas('student1', only='deadline_expired')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 1)
self.assertEquals(content[0]['name'], 'g1')
self.assertEquals(content[0]['active_deadline']['deadline_expired'], True)
def test_only_deadline_not_expired(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1).d1:ends(1)')
self.testhelper.add_to_path('uni;sub.p1.a1.g2:candidate(student1).d1:ends(70)')
content, response = self._getas('student1', only='deadline_not_expired')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 1)
self.assertEquals(content[0]['name'], 'g2')
self.assertEquals(content[0]['active_deadline']['deadline_expired'], False)
def test_hard_deadlines(self):
# Add 2 assignments to the active period:
# - one hard
# - 2 groups, one after deadline
# - one soft
# - 2 groups, one after deadline
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1).d1') # Expired deadline
self.testhelper.add_to_path('uni;sub.p1.a1.g2:candidate(student1).d1:ends(80)') # In the future
self.testhelper.add_to_path('uni;sub.p1.a2.g3:candidate(student1).d1') # Expired deadline
self.testhelper.add_to_path('uni;sub.p1.a2.g4:candidate(student1).d1:ends(80)') # In the future
self.assertTrue(self.testhelper.sub_p1_a1_g1_d1.deadline < datetime.now())
self.assertTrue(self.testhelper.sub_p1_a1_g2_d1.deadline > datetime.now())
self.assertTrue(self.testhelper.sub_p1_a2_g3_d1.deadline < datetime.now())
self.assertTrue(self.testhelper.sub_p1_a2_g4_d1.deadline > datetime.now())
self.testhelper.sub_p1_a2.deadline_handling = 1 # Hard deadlines on a2
self.testhelper.sub_p1_a2.save()
content, response = self._getas('student1')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 3)
groupnames = set([group['name'] for group in content])
self.assertEquals(groupnames, set(['g1', 'g2', 'g4']))
class TestUserInfo(TestCase):
def setUp(self):
self.client = RestClient()
self.url = '/devilry_authenticateduserinfo/userinfo'
self.testhelper = TestHelper()
self.testhelper.add(nodes="uni:admin(nodeadm)",
subjects=["sub:admin(subjectadm)"],
periods=["p1:admin(periodadm):begins(-2):ends(6)"],
assignments=["a1:admin(assignmentadm)"])
self.testhelper.create_superuser('grandma')
self.testhelper.create_user('nobody')
self.testhelper.add_to_path('uni;sub.p1.a1.g1:examiner(examiner1):candidate(student1)')
def _getas(self, username):
self.client.login(username=username, password='******')
return self.client.rest_get(self.url)
def _get_and_sanitytest_as(self, username, is_superuser=False,
is_nodeadmin=False, is_subjectadmin=False,
is_periodadmin=False, is_assignmentadmin=False,
is_student=False, is_examiner=False):
content, response = self._getas(username)
self.assertEquals(response.status_code, 200)
self.assertEquals(set(content.keys()),
set(['id', 'username', 'languagecode', 'email',
'full_name', 'is_superuser', 'is_nodeadmin',
'is_subjectadmin', 'is_periodadmin',
'is_assignmentadmin', 'is_examiner', 'is_student']))
self.assertEquals(content['is_superuser'], is_superuser)
self.assertEquals(content['is_nodeadmin'], is_nodeadmin)
self.assertEquals(content['is_subjectadmin'], is_subjectadmin)
self.assertEquals(content['is_periodadmin'], is_periodadmin)
self.assertEquals(content['is_assignmentadmin'], is_assignmentadmin)
self.assertEquals(content['is_student'], is_student)
self.assertEquals(content['is_examiner'], is_examiner)
return content
def test_as_superuser(self):
content = self._get_and_sanitytest_as('grandma', is_superuser=True)
def test_as_nodeadmin(self):
content = self._get_and_sanitytest_as('nodeadm', is_nodeadmin=True)
def test_as_subjectadmin(self):
content = self._get_and_sanitytest_as('subjectadm', is_subjectadmin=True)
def test_as_periodadmin(self):
content = self._get_and_sanitytest_as('periodadm', is_periodadmin=True)
def test_as_assignmentadmin(self):
content = self._get_and_sanitytest_as('assignmentadm', is_assignmentadmin=True)
def test_as_student(self):
content = self._get_and_sanitytest_as('student1', is_student=True)
def test_as_examiner(self):
content = self._get_and_sanitytest_as('examiner1', is_examiner=True)
def test_as_nobody(self):
nobody = self.testhelper.nobody
nobody.devilryuserprofile.full_name = 'A true nobody'
nobody.devilryuserprofile.languagecode = 'en_US'
nobody.devilryuserprofile.save()
content = self._get_and_sanitytest_as('nobody')
self.assertEquals(content['email'], '*****@*****.**')
self.assertEquals(content['full_name'], 'A true nobody')
self.assertEquals(content['languagecode'], 'en_US')
self.assertEquals(content['username'], 'nobody')
self.assertEquals(content['id'], self.testhelper.nobody.id)
class TestRestAggregatedGroupInfo(TestCase):
def setUp(self):
self.client = RestClient()
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['p1:begins(-1)'],
assignments=['a1'])
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1,student2):examiner(examiner1).d1:ends(5)')
self.testhelper.add_to_path('uni;sub.p1.a1.g1.d2:ends(10)')
self.group = self.testhelper.sub_p1_a1_g1
self.url = '/devilry_student/rest/aggregated-groupinfo/{0}'.format(self.group.id)
def _getas(self, username):
self.client.login(username=username, password='******')
return self.client.rest_get(self.url)
def test_nobody(self):
self.testhelper.create_user('nobody')
content, response = self._getas('nobody')
self.assertEquals(response.status_code, 403)
def test_groupinfo(self):
content, response = self._getas('student1')
self.assertEquals(response.status_code, 200)
self.assertEquals(set(content.keys()),
set(['id', 'name', 'is_open', 'candidates', 'examiners',
'deadlines', 'active_feedback',
'deadline_handling', 'breadcrumbs']))
self.assertEquals(content['id'], self.group.id)
self.assertEquals(content['name'], 'g1')
self.assertEquals(content['is_open'], True)
self.assertEquals(content['deadline_handling'], 0)
self.assertEquals(content['active_feedback'], None)
def test_candidates(self):
content, response = self._getas('student1')
candidates = content['candidates']
self.assertEquals(len(candidates), 2)
self.assertEquals(set(candidates[0].keys()),
set(['id', 'candidate_id', 'identifier', 'user']))
self.assertEquals(set(candidates[0]['user'].keys()),
set(['id', 'username', 'email', 'full_name', 'displayname']))
def test_examiners(self):
content, response = self._getas('student1')
examiners = content['examiners']
self.assertEquals(len(examiners), 1)
self.assertEquals(set(examiners[0].keys()),
set(['id', 'user']))
self.assertEquals(set(examiners[0]['user'].keys()),
set(['id', 'username', 'email', 'full_name', 'displayname']))
self.assertEquals(examiners[0]['user']['username'], 'examiner1')
def test_examiners_anonymous(self):
self.group.parentnode.anonymous = True
self.group.parentnode.save()
content, response = self._getas('student1')
examiners = content['examiners']
self.assertEquals(examiners, None)
def test_deadlines(self):
content, response = self._getas('student1')
deadlines = content['deadlines']
self.assertEquals(len(deadlines), 2)
self.assertEquals(set(deadlines[0].keys()),
set(['id', 'deadline', 'deliveries', 'text',
'offset_from_now', 'in_the_future']))
def test_breadcrumbs(self):
content, response = self._getas('student1')
breadcrumbs = content['breadcrumbs']
self.assertEquals(breadcrumbs,
{u'assignment': {u'id': self.group.parentnode.id,
u'long_name': u'A1',
u'short_name': u'a1'},
u'period': {u'id': self.group.parentnode.parentnode.id,
u'long_name': u'P1',
u'short_name': u'p1'},
u'subject': {u'id': self.group.parentnode.parentnode.parentnode.id,
u'long_name': u'Sub',
u'short_name': u'sub'}})
class TestRestCreateNewAssignmentIntegration(TestCase):
def setUp(self):
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['p1:admin(p1admin)', 'p2'])
self.client = RestClient()
self.url = '/devilry_subjectadmin/rest/createnewassignment/'
def _login_p1admin(self):
self.client.login(username='******', password='******')
def _get_testdata(self):
publishing_time = self.testhelper.sub_p1.start_time + timedelta(days=1)
first_deadline = self.testhelper.sub_p1.start_time + timedelta(days=2)
return dict(period_id=self.testhelper.sub_p1.id,
short_name='a', long_name='Aa',
first_deadline=isoformat_datetime(first_deadline),
publishing_time=isoformat_datetime(publishing_time),
delivery_types=ELECTRONIC, anonymous=False,
setupstudents_mode='do_not_setup',
setupexaminers_mode='do_not_setup')
def test_create(self):
self._login_p1admin()
publishing_time = self.testhelper.sub_p1.start_time + timedelta(days=1)
first_deadline = self.testhelper.sub_p1.start_time + timedelta(days=2)
content, response = self.client.rest_post(self.url, self._get_testdata())
self.assertEquals(response.status_code, 201)
self.assertEquals(set(content.keys()),
set(['id', 'period_id', 'short_name', 'long_name', 'first_deadline', 'anonymous']))
def test_create_notfound(self):
self._login_p1admin()
data = self._get_testdata()
data['period_id'] = 200000
content, response = self.client.rest_post(self.url, data)
self.assertEquals(response.status_code, 403)
def test_create_permissiondenied(self):
self.testhelper.create_user('nopermsuser')
self.client.login(username='******', password='******')
data = self._get_testdata()
content, response = self.client.rest_post(self.url, data)
self.assertEquals(response.status_code, 403)
def test_create_validation(self):
self._login_p1admin()
content, response = self.client.rest_post(self.url, {})
self.assertEquals(response.status_code, 400)
self.assertEquals(content.keys(), ['field_errors'])
for fieldname in ['delivery_types', 'long_name', 'publishing_time', 'short_name']:
self.assertEquals(content['field_errors'][fieldname], [u'This field is required.'])
def test_create_first_deadline_none(self):
self._login_p1admin()
data = self._get_testdata()
data['first_deadline'] = None
data['setupstudents_mode'] = 'allrelated'
content, response = self.client.rest_post(self.url, data)
self.assertEquals(response.status_code, 400)
self.assertTrue(content['field_errors']['first_deadline'][0].startswith('Required when adding'))
class TestSearchForUsers(TestCase):
def setUp(self):
self.client = RestClient()
for username, fullname in [('baldr', 'God of Beauty'),
('freyja', 'Goddess of Love'),
('freyr', 'God of Fertility'),
('kvasir', 'God of Inspiration'),
('loki', 'Trickster and god of Mischief'),
('thor', 'God of thunder and Battle'),
('odin', 'The "All Father"')]:
user = User.objects.create(username=username,
email='{0}@{1}.com'.format(fullname.lower().replace(' ', '.'),
username))
user.devilryuserprofile.full_name = fullname
user.devilryuserprofile.save()
self.testhelper = TestHelper()
self.testhelper.add(nodes="uni:admin(uniadmin)",
subjects=["sub:admin(subadmin)"],
periods=["p1:admin(p1admin)"],
assignments=["a1:admin(a1admin)"])
self.url = '/devilry_usersearch/search'
def _listas(self, username, **data):
self.client.login(username=username, password='******')
return self.client.rest_get(self.url, **data)
def _searchas(self, username, query):
return self._listas(username, query=query)[0]
def _test_search_as(self, username):
content, response = self._listas(username, query='')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(self._searchas(username, 'fre')), 2)
self.assertEquals(len(self._searchas(username, 'fr')), 0)
self.assertEquals(len(self._searchas(username, 'f')), 0)
self.assertEquals(len(self._searchas(username, 'GOD')), 6)
self.assertEquals(len(self._searchas(username, 'god')), 6)
self.assertEquals(len(self._searchas(username, 'thor')), 1)
self.assertEquals(len(self._searchas(username, 'tHoR')), 1)
thor = self._searchas(username, 'tHoR')[0]
self.assertEquals(thor,
{u'username': u'thor',
u'id': User.objects.get(username='******').id,
u'full_name': u'God of thunder and Battle',
u'languagecode': None,
u'email': u'*****@*****.**'})
def test_search_nodeadmin(self):
self._test_search_as('uniadmin')
def test_search_subjectadmin(self):
self._test_search_as('subadmin')
def test_search_periodadmin(self):
self._test_search_as('p1admin')
def test_search_assignmentadmin(self):
self._test_search_as('a1admin')
def test_search_superadmin(self):
self.testhelper.create_superuser('grandma')
self._test_search_as('grandma')
def test_search_nobody(self):
self.testhelper.create_user('nobody')
content, response = self._listas('nobody', query='')
self.assertEquals(response.status_code, 403)
def test_search_limit(self):
for index in xrange(15):
username = '******'.format(index)
user = User.objects.create(username=username,
email='{0}@example.com'.format(username))
self.assertEquals(len(self._searchas('uniadmin', 'student')), 10)
class TestRestDeadlinesBulkList(TestCase):
def setUp(self):
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['p1:begins(-2)'], # 2 months ago
assignments=['a1:admin(adm):pub(0)']) # 0 days after period begins
self.client = RestClient()
self.url = '/devilry_subjectadmin/rest/deadlinesbulk/{0}/'.format(self.testhelper.sub_p1_a1.id)
def _listas(self, username, **data):
self.client.login(username=username, password='******')
return self.client.rest_get(self.url, **data)
def test_get_empty(self):
content, response = self._listas('adm')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 0)
def test_get_simple(self):
for groupnum in xrange(3):
# deadline 5 days after assignment starts
self.testhelper.add_to_path('uni;sub.p1.a1.g{0}.d1:ends(5)'.format(groupnum))
content, response = self._listas('adm')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 1)
d1 = content[0]
self.assertEquals(set(d1.keys()),
set(['deadline', 'text', 'groups', 'offset_from_now',
'in_the_future', 'bulkdeadline_id', 'url', 'groups']))
self.assertEquals(len(d1['groups']), 3)
self.assertEquals(d1['in_the_future'], False)
self.assertEquals(d1['text'], None)
def test_get_textdifference(self):
for groupnum in xrange(3):
# deadline 5 days after assignment starts
self.testhelper.add_to_path('uni;sub.p1.a1.g{0}.d1:ends(5)'.format(groupnum))
# Change text on g1_d1, which should make it a separate entry in the list
self.testhelper.sub_p1_a1_g1_d1.text = 'Test'
self.testhelper.sub_p1_a1_g1_d1.save()
content, response = self._listas('adm')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 2)
g2_g3_d1 = content[0]
g1_d1 = content[1]
self.assertEquals(g1_d1['text'], 'Test')
self.assertEquals(len(g1_d1['groups']), 1)
self.assertEquals(g2_g3_d1['text'], None)
self.assertEquals(len(g2_g3_d1['groups']), 2)
def test_get_multiple_and_order(self):
for groupnum in xrange(3):
# deadline 5 days after assignment starts
self.testhelper.add_to_path('uni;sub.p1.a1.g{0}.d1:ends(5)'.format(groupnum))
for groupnum in xrange(2):
# deadline 70 days after assignment starts, which should be in the future
self.testhelper.add_to_path('uni;sub.p1.a1.g{0}.d2:ends(70)'.format(groupnum))
content, response = self._listas('adm')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 2)
d1 = content[1]
d2 = content[0]
self.assertEquals(len(d1['groups']), 3)
self.assertEquals(d1['in_the_future'], False)
self.assertEquals(len(d2['groups']), 2)
self.assertEquals(d2['in_the_future'], True)
def test_get_nobody(self):
self.testhelper.create_user('nobody')
content, response = self._listas('nobody')
self.assertEquals(response.status_code, 403)
