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 TestAssignment(SubjectAdminSeleniumTestCase):
def setUp(self):
self.testhelper = TestHelper()
def _browseToAssignment(self, id):
self.browseTo('/assignment/{id}/'.format(id=id))
def test_doesnotexists(self):
self.testhelper.create_user('normal')
self.login('normal')
self._browseToAssignment(100000)
self.waitForCssSelector('.devilry_extjsextras_alertmessagelist')
self.assertTrue('403: FORBIDDEN' in self.selenium.page_source)
def test_doesnotexists_superadmin(self):
self.testhelper.create_superuser('grandma')
self.login('grandma')
self._browseToAssignment(100000)
self.waitForCssSelector('.devilry_extjsextras_alertmessagelist')
self.assertTrue('404: NOT FOUND' in self.selenium.page_source)
def test_shortcuts_render(self):
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['period1'],
assignments=['week2:pub(2):admin(week2admin)'])
self.login('week2admin')
self._browseToAssignment(self.testhelper.sub_period1_week2.id)
self.waitForCssSelector('.devilry_subjectadmin_assignmentoverview')
self.assertTrue('Manage students' in self.selenium.page_source)
self.assertTrue('Manage deadlines' in self.selenium.page_source)
def test_title(self):
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['period1'],
assignments=['week2:pub(2):admin(week2admin)'])
self.login('week2admin')
self._browseToAssignment(self.testhelper.sub_period1_week2.id)
self.waitForCssSelector('.devilry_subjectadmin_assignmentoverview')
self.assertEquals(self.selenium.title, 'sub.period1.week2 - Devilry')
def test_notpublished(self):
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['period1'],
assignments=['week2:pub(2):admin(week2admin)'])
self.login('week2admin')
self._browseToAssignment(self.testhelper.sub_period1_week2.id)
self.waitForText('>Not published')
def test_published(self):
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['period1:begins(-2)'],
assignments=['week2:admin(week2admin)'])
self.login('week2admin')
self._browseToAssignment(self.testhelper.sub_period1_week2.id)
self.waitForText('>Published')
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 TestEmailSendingDebugView(TestCase):
def setUp(self):
self.client = Client()
self.testhelper = TestHelper()
self.nobody = self.testhelper.create_user('nobody')
self.superuser = self.testhelper.create_superuser('superuser')
self.url = reverse('send_email_to_students_email_sending_debug',
kwargs={'username': '******'})
def test_email_sending_debug_nobody(self):
self.client.login(username='******', password='******')
response = self.client.get(self.url)
self.assertEqual(response.status_code, 403)
def test_email_sending_debug(self):
self.testhelper.create_user('targetuser')
self.client.login(username='******', password='******')
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
self.assertTrue('<html>' in response.content)
self.assertTrue('*****@*****.**' in response.content)
def test_email_sending_debug_invaliduser(self):
self.client.login(username='******', password='******')
response = self.client.get(self.url)
self.assertEqual(response.status_code, 404)
self.assertEqual(response.content, 'ERROR: User "targetuser" does not exist')
def test_email_sending_debug_noemail(self):
targetuser = self.testhelper.create_user('targetuser')
targetuser.email = ''
targetuser.save()
self.client.login(username='******', password='******')
response = self.client.get(self.url)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, 'ERROR: User "targetuser" has no email address')
def test_email_sending_debug_superuser_noemail(self):
targetuser = self.testhelper.create_user('targetuser')
superuser = self.testhelper.superuser
superuser.email = ''
superuser.save()
self.client.login(username='******', password='******')
response = self.client.get(self.url)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, 'ERROR: YOU (superuser) have no email address')
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.serialize()
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 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 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 TestStatusPrintView(TestCase):
def setUp(self):
self.testhelper = TestHelper()
self.testhelper.create_superuser('superuser')
def _get_url(self, status_id):
return reverse('devilry_qualifiesforexam_statusprint', kwargs={'status_id': status_id})
def _getas(self, username, status_id):
self.client.login(username=username, password='******')
return self.client.get(self._get_url(status_id))
def test_status_not_found(self):
response = self._getas('superuser', 1)
self.assertEqual(response.status_code, 404)
def test_status_forbidden(self):
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['p1:admin(periodadmin):begins(-3):ends(6)'])
status = Status.objects.create(
user=self.testhelper.superuser,
period=self.testhelper.sub_p1,
status=Status.READY)
self.testhelper.create_user('nobody')
response = self._getas('nobody', status.pk)
self.assertEqual(response.status_code, 403)
def test_status_not_ready(self):
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['p1:admin(periodadmin):begins(-3):ends(6)'])
status = Status.objects.create(
user=self.testhelper.superuser,
period=self.testhelper.sub_p1,
status=Status.NOTREADY)
response = self._getas('superuser', status.pk)
self.assertEqual(response.status_code, 404)
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 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 TestDashboardUI(StudentSeleniumTestCase):
def setUp(self):
self.fileinfo = {'ok.py': ['print ', 'meh']}
self.testhelper = TestHelper()
self.testhelper.create_user('student1')
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['p1:begins(-3):ends(10)'], # -3months
assignments=['a1:pub(1)', # 1 days after p1 begins
'a2:pub(30)']) # 30days after p1 begins
def _browseToDashboard(self):
self.browseTo('')
def test_not_student(self):
self.login('student1')
self._browseToDashboard()
self.waitForCssSelector('.devilry_student_dashboard')
self.assertTrue('You have no active electronic assignments' in self.selenium.page_source)
self.assertTrue('Other assignments' in self.selenium.page_source)
self.assertTrue('Browse all your assignments' in self.selenium.page_source)
self.assertTrue('Search your assignments' in self.selenium.page_source)
#
#
# Not expired deadlines
#
#
def test_open_before_deadline(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1):examiner(examiner1)')
self.testhelper.add_to_path('uni;sub.p1.a1.g1.d1:ends(110)') # 110 days after a1 published
deadline1 = self.testhelper.sub_p1_a1_g1_d1
self.login('student1')
self._browseToDashboard()
self.waitForCssSelector('.devilry_student_dashboard')
self.waitForCssSelector('.devilry_student_opengroupsgrid.not_expired')
grid = self.selenium.find_element_by_css_selector('.devilry_student_opengroupsgrid.not_expired')
rows = grid.find_elements_by_css_selector('.x-grid-row')
self.assertEquals(len(rows), 1)
row0 = rows[0]
self.assertEquals(row0.find_element_by_css_selector('.ident').text.strip(), 'sub - A1')
self.assertEquals(row0.find_element_by_css_selector('.deliveries').text.strip(), 'Deliveries: 0')
self.assertEquals(len(row0.find_elements_by_css_selector('.deadlinedelta.success')), 1)
self.assertEquals(len(row0.find_elements_by_css_selector('.deadlinedelta.danger')), 0)
self.assertEquals(row0.find_element_by_css_selector('.deadline').text.strip(),
'Deadline: {0}'.format(ui_datetimeformat(deadline1.deadline)))
def test_multiple_open_before_deadline(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1)')
self.testhelper.add_to_path('uni;sub.p1.a1.g1.d1:ends(110)') # 110 days after a1 published
self.testhelper.add_to_path('uni;sub.p1.a2.g1:candidate(student1)')
self.testhelper.add_to_path('uni;sub.p1.a2.g1.d1:ends(100)') # 100 days after a2 published
self.login('student1')
self._browseToDashboard()
self.waitForCssSelector('.devilry_student_dashboard')
self.waitForCssSelector('.devilry_student_opengroupsgrid.not_expired')
grid = self.selenium.find_element_by_css_selector('.devilry_student_opengroupsgrid.not_expired')
rows = grid.find_elements_by_css_selector('.x-grid-row')
self.assertEquals(len(rows), 2)
self.assertEquals(rows[0].find_element_by_css_selector('.ident').text.strip(), 'sub - A1')
self.assertEquals(rows[1].find_element_by_css_selector('.ident').text.strip(), 'sub - A2')
def test_open_before_deadline_deliveries(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1)')
self.testhelper.add_to_path('uni;sub.p1.a1.g1.d1:ends(110)') # 110 days after a1 published
for x in xrange(3):
self.testhelper.add_delivery('sub.p1.a1.g1', self.fileinfo)
self.login('student1')
self._browseToDashboard()
self.waitForCssSelector('.devilry_student_dashboard')
self.waitForCssSelector('.devilry_student_opengroupsgrid.not_expired')
grid = self.selenium.find_element_by_css_selector('.devilry_student_opengroupsgrid.not_expired')
rows = grid.find_elements_by_css_selector('.x-grid-row')
self.assertEquals(len(rows), 1)
self.assertEquals(rows[0].find_element_by_css_selector('.ident').text.strip(), 'sub - A1')
self.assertEquals(rows[0].find_element_by_css_selector('.deliveries').text.strip(), 'Deliveries: 3')
#
#
# Expired deadlines
#
#
def test_open_deadline_expired(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1)')
self.testhelper.add_to_path('uni;sub.p1.a1.g1.d1:ends(20)') # 20 days after a1 published (which is in the past)
deadline1 = self.testhelper.sub_p1_a1_g1_d1
self.login('student1')
self._browseToDashboard()
self.waitForCssSelector('.devilry_student_dashboard')
self.waitForCssSelector('.devilry_student_opengroupsgrid.expired')
grid = self.selenium.find_element_by_css_selector('.devilry_student_opengroupsgrid.expired')
rows = grid.find_elements_by_css_selector('.x-grid-row')
self.assertEquals(len(rows), 1)
row0 = rows[0]
self.assertEquals(row0.find_element_by_css_selector('.ident').text.strip(), 'sub - A1')
self.assertEquals(row0.find_element_by_css_selector('.deliveries').text.strip(), 'Deliveries: 0')
self.assertEquals(len(row0.find_elements_by_css_selector('.deadlinedelta.success')), 0)
self.assertEquals(len(row0.find_elements_by_css_selector('.deadlinedelta.danger')), 1)
self.assertEquals(row0.find_element_by_css_selector('.deadline').text.strip(),
'Deadline: {0}'.format(ui_datetimeformat(deadline1.deadline)))
self.assertTrue('You have no active electronic assignments' in self.selenium.page_source)
def test_multiple_open_deadline_expired(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1)')
self.testhelper.add_to_path('uni;sub.p1.a1.g1.d1:ends(20)') # 110 days after a1 published
self.testhelper.add_to_path('uni;sub.p1.a2.g1:candidate(student1)')
self.testhelper.add_to_path('uni;sub.p1.a2.g1.d1:ends(30)') # 100 days after a2 published
self.login('student1')
self._browseToDashboard()
self.waitForCssSelector('.devilry_student_dashboard')
self.waitForCssSelector('.devilry_student_opengroupsgrid.expired')
grid = self.selenium.find_element_by_css_selector('.devilry_student_opengroupsgrid.expired')
rows = grid.find_elements_by_css_selector('.x-grid-row')
self.assertEquals(len(rows), 2)
self.assertEquals(rows[0].find_element_by_css_selector('.ident').text.strip(), 'sub - A1')
self.assertEquals(rows[1].find_element_by_css_selector('.ident').text.strip(), 'sub - A2')
def test_open_deadline_expired_deliveries(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1)')
self.testhelper.add_to_path('uni;sub.p1.a1.g1.d1:ends(20)') # 20 days after a1 published (which is in the past)
for x in xrange(3):
self.testhelper.add_delivery('sub.p1.a1.g1', self.fileinfo)
self.login('student1')
self._browseToDashboard()
self.waitForCssSelector('.devilry_student_dashboard')
self.waitForCssSelector('.devilry_student_opengroupsgrid.expired')
grid = self.selenium.find_element_by_css_selector('.devilry_student_opengroupsgrid.expired')
rows = grid.find_elements_by_css_selector('.x-grid-row')
self.assertEquals(len(rows), 1)
self.assertEquals(rows[0].find_element_by_css_selector('.ident').text.strip(), 'sub - A1')
self.assertEquals(rows[0].find_element_by_css_selector('.deliveries').text.strip(), 'Deliveries: 3')
#
#
# Hard deadlines
#
#
def test_hard_deadlines(self):
# Test that hard deadlines actually show up before they expire, but not after
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1)')
self.testhelper.add_to_path('uni;sub.p1.a1.g1.d1:ends(10)') # 10 days after a1 published (in the past)
self.testhelper.add_to_path('uni;sub.p1.a2.g1:candidate(student1)')
self.testhelper.add_to_path('uni;sub.p1.a2.g1.d1:ends(110)') # 110 days after a1 published (in the future)
self.assertTrue(self.testhelper.sub_p1_a1_g1_d1.deadline < datetime.now())
self.assertTrue(self.testhelper.sub_p1_a2_g1_d1.deadline > datetime.now())
# Hard deadlines
for assignment in (self.testhelper.sub_p1_a1, self.testhelper.sub_p1_a2):
assignment.deadline_handling = 1
assignment.save()
self.login('student1')
self._browseToDashboard()
self.waitForCssSelector('.devilry_student_dashboard')
self.waitForCssSelector('.devilry_student_opengroupsgrid.not_expired')
grid = self.selenium.find_element_by_css_selector('.devilry_student_opengroupsgrid.not_expired')
rows = grid.find_elements_by_css_selector('.x-grid-row')
self.assertEquals(len(rows), 1)
self.assertEquals(rows[0].find_element_by_css_selector('.ident').text.strip(), 'sub - A2')
# Make sure A1 does not end up in the expired SOFT deadlines grid
expiredgrid = self.selenium.find_element_by_css_selector('.devilry_student_opengroupsgrid.expired')
expiredrows = expiredgrid.find_elements_by_css_selector('.x-grid-row')
self.assertEquals(len(expiredrows), 0)
#
#
# Recent deliveries
#
#
def test_recent_deliveries(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1)')
self.testhelper.add_to_path('uni;sub.p1.a1.g1.d1:ends(110)') # 110 days after a1 published
for x in xrange(3):
self.testhelper.add_delivery('sub.p1.a1.g1', self.fileinfo, time_of_delivery=x)
self.login('student1')
self._browseToDashboard()
self.waitForCssSelector('.devilry_student_dashboard')
self.waitForCssSelector('.devilry_student_recentdeliveriesgrid')
grid = self.selenium.find_element_by_css_selector('.devilry_student_recentdeliveriesgrid')
rows = grid.find_elements_by_css_selector('.x-grid-row')
self.assertEquals(len(rows), 3)
self.assertEquals(rows[0].find_element_by_css_selector('.ident').text.strip(), 'sub - a1 - #3')
self.assertEquals(rows[1].find_element_by_css_selector('.ident').text.strip(), 'sub - a1 - #2')
self.assertEquals(rows[2].find_element_by_css_selector('.ident').text.strip(), 'sub - a1 - #1')
def test_recent_feedbacks(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1):examiner(examiner1)')
self.testhelper.add_to_path('uni;sub.p1.a1.g1.d1:ends(110)') # 110 days after a1 published
# Add 2 deliveries, delivery1 has 2 feedbacks, and delivery2 has 1 feedback.
delivery1 = self.testhelper.add_delivery('sub.p1.a1.g1', self.fileinfo)
self.testhelper.add_feedback(delivery1,
verdict={'grade': 'A', 'points': 10, 'is_passing_grade': True})
delivery1feedback = self.testhelper.add_feedback(delivery1,
verdict={'grade': 'F', 'points': 2, 'is_passing_grade': False})
delivery2 = self.testhelper.add_delivery('sub.p1.a1.g1', self.fileinfo)
delivery2feedback = self.testhelper.add_feedback(delivery2,
verdict={'grade': 'C', 'points': 5, 'is_passing_grade': True})
self.login('student1')
self._browseToDashboard()
self.waitForCssSelector('.devilry_student_dashboard')
self.waitForCssSelector('.devilry_student_recentfeedbacksgrid')
grid = self.selenium.find_element_by_css_selector('.devilry_student_recentfeedbacksgrid')
rows = grid.find_elements_by_css_selector('.x-grid-row')
self.assertEquals(len(rows), 2) # Notice that only 2 is included - because only active feedbacks are included
self.assertEquals(rows[0].find_element_by_css_selector('.ident').text.strip(), 'sub - a1 - #2')
self.assertEquals(rows[0].find_element_by_css_selector('.passing_grade.success').text.strip(), 'Passed')
self.assertEquals(rows[0].find_element_by_css_selector('.grade').text.strip(), '(C)')
self.assertEquals(rows[1].find_element_by_css_selector('.ident').text.strip(), 'sub - a1 - #1')
self.assertEquals(rows[1].find_element_by_css_selector('.failing_grade.danger').text.strip(), 'Failed')
self.assertEquals(rows[1].find_element_by_css_selector('.grade').text.strip(), '(F)')
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 TestRestStatus(TransactionTestCase):
def setUp(self):
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni:admin(uniadmin)',
subjects=['sub'],
periods=[
'oldperiod:admin(periodadmin):begins(-12):ends(2)',
'p1:admin(periodadmin):begins(-3):ends(6)',
'p2:admin(periodadmin):begins(-1):ends(6)'])
self.client = RestClient()
self.url = reverse('devilry_qualifiesforexam-rest-status')
self.testhelper.create_superuser('superuser')
qualifiesforexam_plugins.add(
id = 'devilry_qualifiesforexam.test.noop-plugin',
url = '/some/noop-url',
title = 'Noop',
post_statussave=noop,
description = 'noop',
pluginsettings_summary_generator = lambda status: 'noop summary'
)
def tearDown(self):
for pluginid in ('devilry_qualifiesforexam.test.plugin', 'devilry_qualifiesforexam.test.noop-plugin'):
if pluginid in qualifiesforexam_plugins:
del qualifiesforexam_plugins.items[pluginid]
def _get_url(self, periodid=None):
if periodid:
return '{0}{1}'.format(self.url, periodid)
else:
return self.url
def _create_relatedstudent(self, username, fullname=None):
user = getattr(self.testhelper, username, None)
if not user:
user = self.testhelper.create_user(username, fullname=fullname)
relstudent = self.testhelper.sub_p1.relatedstudent_set.create(user=user)
return relstudent
def _postas(self, username, data):
self.client.login(username=username, password='******')
return self.client.rest_post(self._get_url(), data)
def _test_post_as(self, username):
self.assertEquals(Status.objects.count(), 0)
relatedStudent1 = self._create_relatedstudent('student1', 'Student One')
relatedStudent2 = self._create_relatedstudent('student2', 'Student Two')
content, response = self._postas(username, {
'period': self.testhelper.sub_p1.id,
'status': 'ready',
'message': 'This is a test',
'plugin': 'devilry_qualifiesforexam.test.noop-plugin',
'pluginsessionid': 'tst',
'passing_relatedstudentids': [relatedStudent1.id]
})
self.assertEquals(response.status_code, 201)
self.assertEquals(Status.objects.count(), 1)
status = Status.objects.all()[0]
self.assertEquals(status.period, self.testhelper.sub_p1)
self.assertEquals(status.status, 'ready')
self.assertEquals(status.message, 'This is a test')
self.assertEquals(status.plugin, 'devilry_qualifiesforexam.test.noop-plugin')
self.assertEqual(status.students.count(), 2)
qualifies1 = status.students.get(relatedstudent=relatedStudent1)
qualifies2 = status.students.get(relatedstudent=relatedStudent2)
self.assertTrue(qualifies1.qualifies)
self.assertFalse(qualifies2.qualifies)
def test_post_as_periodadmin(self):
self._test_post_as(self.testhelper.periodadmin)
def test_post_as_nodeadmin(self):
self._test_post_as(self.testhelper.uniadmin)
def test_post_as_superuser(self):
self._test_post_as(self.testhelper.superuser)
def test_post_as_nobody(self):
self.testhelper.create_user('nobody')
content, response = self._postas('nobody', {
'period': self.testhelper.sub_p1.id,
'status': 'ready',
'message': 'This is a test',
'plugin': 'devilry_qualifiesforexam.test.noop-plugin',
'pluginsessionid': 'tst',
'passing_relatedstudentids': [10]
})
self.assertEqual(response.status_code, 403)
def test_post_almostready(self):
relatedStudent1 = self._create_relatedstudent('student1', 'Student One')
relatedStudent2 = self._create_relatedstudent('student2', 'Student Two')
content, response = self._postas('periodadmin', {
'period': self.testhelper.sub_p1.id,
'status': 'almostready',
'message': 'This is a test',
'plugin': 'devilry_qualifiesforexam.test.noop-plugin',
'pluginsessionid': 'tst',
'passing_relatedstudentids': [relatedStudent1.id],
'notready_relatedstudentids': [relatedStudent2.id]
})
self.assertEquals(response.status_code, 201)
status = Status.objects.all()[0]
self.assertEquals(status.status, 'almostready')
self.assertEqual(status.students.count(), 2)
qualifies1 = status.students.get(relatedstudent=relatedStudent1)
qualifies2 = status.students.get(relatedstudent=relatedStudent2)
self.assertTrue(qualifies1.qualifies)
self.assertIsNone(qualifies2.qualifies)
def test_post_notreadystudents_with_invalidstatus(self):
relatedStudent1 = self._create_relatedstudent('student1', 'Student One')
content, response = self._postas('periodadmin', {
'period': self.testhelper.sub_p1.id,
'status': 'ready', # Could choose any status except almostready for this test to be valid
'plugin': 'devilry_qualifiesforexam.test.noop-plugin',
'pluginsessionid': 'tst',
'notready_relatedstudentids': [relatedStudent1.id]
})
self.assertEquals(response.status_code, 400)
self.assertEqual(content['details'],
u'Only the ``almostready`` status allows marking students as not ready for export.')
def test_post_notready_check_studentsignored(self):
relatedStudent1 = self._create_relatedstudent('student1', 'Student One')
content, response = self._postas('periodadmin', {
'period': self.testhelper.sub_p1.id,
'status': 'notready',
'pluginsessionid': 'tst',
'message': 'Test'
})
self.assertEquals(response.status_code, 201)
status = Status.objects.all()[0]
self.assertEquals(status.status, 'notready')
self.assertEquals(status.message, 'Test')
self.assertEqual(status.students.count(), 0)
def test_post_notready_messagerequired(self):
relatedStudent1 = self._create_relatedstudent('student1', 'Student One')
content, response = self._postas('periodadmin', {
'period': self.testhelper.sub_p1.id,
'status': 'notready',
'pluginsessionid': 'tst',
'message': ' ',
'plugin': 'devilry_qualifiesforexam.test.noop-plugin'
})
self.assertEquals(response.status_code, 400)
self.assertEqual(content['errors'][0], u'Message can not be empty when status is ``notready``.')
def test_post_invalidstatus(self):
relatedStudent1 = self._create_relatedstudent('student1', 'Student One')
content, response = self._postas('periodadmin', {
'period': self.testhelper.sub_p1.id,
'status': 'invalidstatus',
'pluginsessionid': 'tst',
'plugin': 'devilry_qualifiesforexam.test.noop-plugin',
'passing_relatedstudentids': [relatedStudent1.id]
})
self.assertEqual(response.status_code, 400)
self.assertEqual(content['field_errors']['status'][0],
u'Select a valid choice. invalidstatus is not one of the available choices.')
def _getinstanceas(self, username, periodid):
self.client.login(username=username, password='******')
return self.client.rest_get(self._get_url(periodid))
def _test_getinstance_as(self, username):
relatedStudent1 = self._create_relatedstudent('student1', 'Student One')
relatedStudent2 = self._create_relatedstudent('student2', 'Student Two')
status = Status(
period = self.testhelper.sub_p1,
status = 'ready',
message = 'Test',
user = getattr(self.testhelper, username),
plugin = 'devilry_qualifiesforexam.test.noop-plugin'
)
status.save()
status.students.create(relatedstudent=relatedStudent1, qualifies=True)
status.students.create(relatedstudent=relatedStudent2, qualifies=False)
content, response = self._getinstanceas(username, self.testhelper.sub_p1.id)
self.assertEqual(response.status_code, 200)
self.assertEqual(set(content.keys()),
set(['id', 'perioddata', 'statuses', u'is_active', u'short_name', u'long_name', u'subject']))
self.assertEqual(content['id'], self.testhelper.sub_p1.id)
statuses = content['statuses']
self.assertEqual(len(statuses), 1)
self.assertEqual(set(statuses[0].keys()),
set([u'id', u'status', u'plugin', u'statustext',
u'period', u'passing_relatedstudentids_map',
u'user', u'message', u'createtime', u'pluginsettings_summary',
u'plugin_description', u'plugin_title']))
self.assertEqual(statuses[0]['period'], self.testhelper.sub_p1.id)
self.assertEqual(statuses[0]['status'], 'ready')
self.assertEqual(statuses[0]['message'], 'Test')
self.assertEqual(statuses[0]['plugin'], 'devilry_qualifiesforexam.test.noop-plugin')
self.assertEqual(statuses[0]['pluginsettings_summary'], 'noop summary')
self.assertIn(str(relatedStudent1.id), statuses[0]['passing_relatedstudentids_map'])
def test_getinstance_as_periodadmin(self):
self._test_getinstance_as('periodadmin')
def test_getinstance_as_nodeadmin(self):
self._test_getinstance_as('uniadmin')
def test_getinstance_as_superuser(self):
self._test_getinstance_as('superuser')
def test_getinstanceas_nobody(self):
self.testhelper.create_user('nobody')
content, response = self._getinstanceas('nobody', self.testhelper.sub_p1.id)
self.assertEqual(response.status_code, 403)
def test_getinstance_no_statuses(self):
content, response = self._getinstanceas('periodadmin', self.testhelper.sub_p1.id)
self.assertEqual(response.status_code, 404)
self.assertEquals(content['detail'], u'The period has no statuses')
def test_getinstance_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._getinstanceas('periodadmin', periodid)
self.assertEqual(response.status_code, 404)
self.assertEquals(content['detail'], u'The period with ID 10000 does not exist')
def _getlistas(self, username, **kwargs):
self.client.login(username=username, password='******')
return self.client.rest_get(self._get_url(), **kwargs)
def _createlistteststatus(self, period, status='ready',
plugin='devilry_qualifiesforexam.test.noop-plugin'):
status = Status(
period = period,
status = status,
message = 'Test',
user = self.testhelper.periodadmin,
plugin = plugin
)
status.full_clean()
status.save()
return status
def _test_getlist_as(self, username):
self._createlistteststatus(self.testhelper.sub_oldperiod)
self._createlistteststatus(self.testhelper.sub_p1, status='notready', plugin='')
import time
time.sleep(0.1) # Sleep to make sure the status below is the active status
status = self._createlistteststatus(self.testhelper.sub_p1)
content, response = self._getlistas(username)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(content), 2)
p1info = content[0]
self.assertEqual(p1info['id'], self.testhelper.sub_p1.id)
self.assertEqual(p1info['active_status']['id'], status.id)
p2info = content[1]
self.assertEqual(p2info['id'], self.testhelper.sub_p2.id)
self.assertEqual(p2info['active_status'], None)
def test_getlist_as_periodadmin(self):
self._test_getlist_as('periodadmin')
def test_getlist_as_nodeadmin(self):
self._test_getlist_as('uniadmin')
def test_getlist_as_superuser(self):
self._test_getlist_as('superuser')
def test_getlist_as_nobody(self):
self.testhelper.create_user('nobody')
content, response = self._getlistas('nobody')
self._createlistteststatus(self.testhelper.sub_p1,
status='notready', plugin='')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(content), 0)
def test_get_within_node(self):
self.testhelper.add(nodes='uni.extra:admin(extraadmin)',
subjects=['othersub'],
periods=['p1:admin(periodadmin):begins(-3):ends(6)'])
content, response = self._getlistas('extraadmin', node_id=self.testhelper.uni_extra.id)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(content), 1)
p1info = content[0]
self.assertEqual(p1info['id'], self.testhelper.othersub_p1.id)
def test_get_within_node_notactive(self):
self.testhelper.add(nodes='uni.extra:admin(extraadmin)',
subjects=['othersub'],
periods=['old:admin(periodadmin):begins(-12):ends(6)'])
content, response = self._getlistas('extraadmin', node_id=self.testhelper.uni_extra.id)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(content), 0)
def test_get_within_node_notadmin_on_requested(self):
self.testhelper.add(nodes='uni.extra:admin(extraadmin)')
content, response = self._getlistas('extraadmin', node_id=self.testhelper.uni.id)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(content), 0)
def test_save_settings(self):
savedsettings = {}
def save_settings(status, settings):
savedsettings['status'] = status
savedsettings['settings'] = settings
qualifiesforexam_plugins.add(
id = 'devilry_qualifiesforexam.test.plugin',
url = '/some/url',
title = 'Test',
description = 'A test',
uses_settings=True,
post_statussave = save_settings
)
self.client.login(username='******', password='******')
session = self.client.session
session[create_settings_sessionkey('tst')] = {'test': 'settings'}
session.save()
content, response = self._postas('periodadmin', {
'period': self.testhelper.sub_p1.id,
'status': 'ready',
'plugin': 'devilry_qualifiesforexam.test.plugin',
'pluginsessionid': 'tst',
'passing_relatedstudentids': []
})
self.assertEqual(response.status_code, 201)
self.assertEqual(len(savedsettings), 2)
self.assertEqual(savedsettings['settings'], {'test': 'settings'})
self.assertIsInstance(savedsettings['status'], Status)
def test_save_settings_missing_sessiondata(self):
def save_settings(status, settings):
pass
qualifiesforexam_plugins.add(
id = 'devilry_qualifiesforexam.test.plugin',
url = '/some/url',
title = 'Test',
uses_settings = True,
description = 'A test',
post_statussave = save_settings
)
self.assertEquals(Status.objects.count(), 0)
content, response = self._postas('periodadmin', {
'period': self.testhelper.sub_p1.id,
'status': 'ready',
'plugin': 'devilry_qualifiesforexam.test.plugin',
'pluginsessionid': 'tst',
'passing_relatedstudentids': []
})
self.assertEqual(response.status_code, 400)
self.assertEqual(content['detail'],
u'The "devilry_qualifiesforexam.test.plugin"-plugin requires settings - no settings found in the session.')
self.assertEquals(Status.objects.count(), 0) # The database rolled back because of the error
def test_fail_verification(self):
def post_statussave(status, settings):
raise PluginResultsFailedVerification('Invalid')
qualifiesforexam_plugins.add(
id = 'devilry_qualifiesforexam.test.plugin',
url = '/some/url',
title = 'Test',
description = 'A test',
post_statussave = post_statussave
)
self.assertEquals(Status.objects.count(), 0)
content, response = self._postas('periodadmin', {
'period': self.testhelper.sub_p1.id,
'status': 'ready',
'plugin': 'devilry_qualifiesforexam.test.plugin',
'pluginsessionid': 'tst',
'passing_relatedstudentids': []
})
self.assertEqual(response.status_code, 400)
self.assertEqual(content['detail'], u'Invalid')
self.assertEquals(Status.objects.count(), 0) # The database rolled back because of the error
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 TestAddDeliveryUI(StudentSeleniumTestCase):
def setUp(self):
self.testhelper = TestHelper()
self.testhelper.create_user('student1')
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['p1:begins(-3):ends(10)'],
assignments=['a1:pub(1):ln(Assignment One)'])
self.tstfile1 = join(this_dir, 'upload_testfile1.txt')
def _browseToAddDelivery(self, groupid):
self.browseTo('/group/{groupid}/@@add-delivery'.format(groupid=groupid))
#def _add_file(self, path):
#filefield = self.selenium.find_element_by_css_selector('.devilry_student_groupinfo_add_delivery input[type=file]')
#filefield.send_keys(path)
#filefield.send_keys(Keys.TAB)
def test_add_delivery(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1).d1')
deadline = self.testhelper.sub_p1_a1_g1_d1
deadline.deadline = datetime.now() + timedelta(days=2)
deadline.save()
self.login('student1')
self._browseToAddDelivery(self.testhelper.sub_p1_a1_g1.id)
self.waitForCssSelector('.devilry_student_groupinfo_add_delivery')
widget = self.selenium.find_element_by_css_selector('.devilry_student_groupinfo_add_delivery')
help = widget.find_element_by_css_selector('.add_delivery_help')
self.assertEquals(help.find_element_by_css_selector('h2').text.strip(),
'Add delivery')
self.assertEquals(help.find_element_by_css_selector('.initial_text').text.strip(),
'Upload files for your delivery. You can upload multiple files.')
self.assertEquals(len(widget.find_elements_by_css_selector('.devilry_student_confirm_delivery_after_deadline')), 0)
self.assertEquals(len(widget.find_elements_by_css_selector('.uploadedfilesbox li')), 0)
#filefield = widget.find_element_by_css_selector('input[type=file]')
#self._add_file(self.tstfile1)
#self.waitFor(widget, lambda w: len(widget.find_elements_by_css_selector('.uploadedfilesbox li')) == 1)
def test_add_delivery_after_deadline(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1).d1')
deadline = self.testhelper.sub_p1_a1_g1_d1
deadline.deadline = datetime.now() - timedelta(days=2)
deadline.save()
self.login('student1')
self._browseToAddDelivery(self.testhelper.sub_p1_a1_g1.id)
self.waitForCssSelector('.devilry_student_groupinfo_add_delivery')
widget = self.selenium.find_element_by_css_selector('.devilry_student_groupinfo_add_delivery')
self.assertEquals(len(widget.find_elements_by_css_selector('.devilry_student_confirm_delivery_after_deadline')), 1)
def test_add_delivery_closed_group(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1)')
self.testhelper.sub_p1_a1_g1.is_open = False
self.testhelper.sub_p1_a1_g1.save()
self.login('student1')
self._browseToAddDelivery(self.testhelper.sub_p1_a1_g1.id)
self.waitForCssSelector('.devilry_extjsextras_alertmessage')
self.assertEquals(self.selenium.find_element_by_css_selector('.devilry_extjsextras_alertmessage').text.strip(),
'Error\nCan not add deliveries on closed groups.')
def test_add_delivery_no_deadline(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1)')
self.login('student1')
self._browseToAddDelivery(self.testhelper.sub_p1_a1_g1.id)
self.waitForCssSelector('.devilry_extjsextras_alertmessage')
self.assertEquals(self.selenium.find_element_by_css_selector('.devilry_extjsextras_alertmessage').text.strip(),
'Error\nCan not add deliveries on a group without a deadline.')
class TestRelatedStudentsUI(SubjectAdminSeleniumTestCase, RelatedUsersUITestMixin):
def setUp(self):
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['p1:admin(p1admin)'])
self.period = self.testhelper.sub_p1
def _browseToManageStudentsAs(self, username, period_id):
path = '/period/{0}/@@relatedstudents'.format(period_id)
self.loginTo(username, path)
self.waitForCssSelector('.devilry_subjectadmin_relatedstudents')
def _add_relatedstudent(self, username, full_name=None, tags='', candidate_id=None):
user = self.testhelper.create_user(username, fullname=full_name)
self.period.relatedstudent_set.create(user=user,
tags=tags,
candidate_id=candidate_id)
def test_render(self):
self._add_relatedstudent('student1', full_name='Student One',
tags='a,b',
candidate_id='SEC-RET')
self._add_relatedstudent('student2')
self._add_relatedstudent('student3', full_name='Student Three')
self._browseToManageStudentsAs('p1admin', self.period.id)
self.waitForCssSelector('.devilry_subjectadmin_relatedusers')
self.waitForGridRowCount(3)
self.assertEquals(self.get_row_data(self.get_row_by_username('student1')),
{'full_name': 'Student One',
'username': '******',
'tags': 'a,b'})
self.assertEquals(self.get_row_data(self.get_row_by_username('student2')),
{'full_name': 'Full name missing',
'username': '******',
'tags': ''})
self.assertEquals(self.get_row_data(self.get_row_by_username('student3')),
{'full_name': 'Student Three',
'username': '******',
'tags': ''})
def test_invalid_period_id(self):
self._browseToManageStudentsAs('p1admin', 1000000)
def find_permissiondeniedmessage(s):
for message in self.selenium.find_elements_by_css_selector('.devilry_extjsextras_alertmessage'):
if 'Permission denied' in message.text.strip():
return True
return False
self.waitFor(self.selenium, find_permissiondeniedmessage)
def test_add_student(self):
self._browseToManageStudentsAs('p1admin', self.period.id)
self.waitForCssSelector('.devilry_subjectadmin_selectrelateduserpanel')
self.testhelper.create_user('student1')
self.assertFalse(self.period.relatedstudent_set.filter(user__username='******').exists())
self.ui_add_related_user('student1')
self.waitForGridRowCount(1)
self.assertTrue(self.period.relatedstudent_set.filter(user__username='******').exists())
def test_add_student_cancel(self):
self._browseToManageStudentsAs('p1admin', self.period.id)
self.waitForCssSelector('.devilry_subjectadmin_selectrelateduserpanel')
self.testhelper.create_user('student1')
self.ui_add_related_user('student1')
self.click_add_related_user_button()
cancelbutton = self.find_element('.devilry_subjectadmin_selectrelateduserpanel .cancelbutton button')
self.waitForDisplayed(cancelbutton)
cancelbutton.click()
self.waitForNotDisplayed(cancelbutton)
def test_remove_single(self):
self._add_relatedstudent('student1')
self._browseToManageStudentsAs('p1admin', self.period.id)
self.waitForCssSelector('.devilry_subjectadmin_relatedusers')
self.waitForGridRowCount(1)
self.ui_remove_related_users('student1')
self.waitForGridRowCount(0)
self.assertFalse(self.period.relatedstudent_set.filter(user__username='******').exists())
def test_remove_many(self):
self._add_relatedstudent('student1')
self._add_relatedstudent('student2', full_name='Student Two')
self._add_relatedstudent('student3', full_name='Student Three')
self._add_relatedstudent('ignored', full_name='Ignored student')
self._browseToManageStudentsAs('p1admin', self.period.id)
self.waitForCssSelector('.devilry_subjectadmin_relatedusers')
self.waitForGridRowCount(4)
self.ui_remove_related_users('student1', 'student2', 'student3')
self.waitForGridRowCount(1)
self.assertFalse(self.period.relatedstudent_set.filter(user__username='******').exists())
self.assertFalse(self.period.relatedstudent_set.filter(user__username='******').exists())
self.assertFalse(self.period.relatedstudent_set.filter(user__username='******').exists())
self.assertTrue(self.period.relatedstudent_set.filter(user__username='******').exists())
def test_remove_enable_disable(self):
self._add_relatedstudent('student1')
self._browseToManageStudentsAs('p1admin', self.period.id)
removebutton = self.waitForAndFindElementByCssSelector('.remove_related_user_button button')
self.assertFalse(removebutton.is_enabled())
self.click_row_by_username('student1')
self.waitForEnabled(removebutton)
self.click_row_by_username('student1')
self.waitForDisabled(removebutton)
def test_add_tags(self):
self._add_relatedstudent('student1', tags='good,bad')
self._add_relatedstudent('student2', tags='a,b')
self._add_relatedstudent('ignored', tags='unchanged')
self._browseToManageStudentsAs('p1admin', self.period.id)
self.click_row_by_username('student1')
self.click_row_by_username('student2')
self.ui_set_or_add_tags('add', ['bad', 'supergood', 'awesome'])
self.assertEquals(self.period.relatedstudent_set.get(user__username='******').tags,
'good,bad,supergood,awesome')
self.assertEquals(self.period.relatedstudent_set.get(user__username='******').tags,
'a,b,bad,supergood,awesome')
self.assertEquals(self.period.relatedstudent_set.get(user__username='******').tags,
'unchanged')
def test_add_tags_cancel(self):
self._add_relatedstudent('student1', tags='good,bad')
self._add_relatedstudent('student2', tags='group1')
self._browseToManageStudentsAs('p1admin', self.period.id)
self.click_row_by_username('student1')
self.click_row_by_username('student2')
self.ui_set_or_add_tags_cancel('add')
self.assertEquals(self.period.relatedstudent_set.get(user__username='******').tags,
'good,bad')
self.assertEquals(self.period.relatedstudent_set.get(user__username='******').tags,
'group1')
def test_set_tags(self):
self._add_relatedstudent('student1', tags='good,bad')
self._add_relatedstudent('student2', tags='a,b')
self._add_relatedstudent('ignored', tags='unchanged')
self._browseToManageStudentsAs('p1admin', self.period.id)
self.click_row_by_username('student1')
self.click_row_by_username('student2')
self.ui_set_or_add_tags('set', ['bad', 'supergood', 'awesome'])
self.assertEquals(self.period.relatedstudent_set.get(user__username='******').tags,
'bad,supergood,awesome')
self.assertEquals(self.period.relatedstudent_set.get(user__username='******').tags,
'bad,supergood,awesome')
self.assertEquals(self.period.relatedstudent_set.get(user__username='******').tags,
'unchanged')
def test_set_tags_cancel(self):
self._add_relatedstudent('student1', tags='good,bad')
self._add_relatedstudent('student2', tags='group1')
self._browseToManageStudentsAs('p1admin', self.period.id)
self.click_row_by_username('student1')
self.click_row_by_username('student2')
self.ui_set_or_add_tags_cancel('set')
self.assertEquals(self.period.relatedstudent_set.get(user__username='******').tags,
'good,bad')
self.assertEquals(self.period.relatedstudent_set.get(user__username='******').tags,
'group1')
def test_clear_tags(self):
self._add_relatedstudent('student1', tags='good,bad')
self._add_relatedstudent('student2', tags='group1')
self._browseToManageStudentsAs('p1admin', self.period.id)
self.click_row_by_username('student1')
self.click_row_by_username('student2')
self.ui_clear_tags()
self.assertEquals(self.period.relatedstudent_set.get(user__username='******').tags,
'')
self.assertEquals(self.period.relatedstudent_set.get(user__username='******').tags,
'')
def test_clear_tags_cancel(self):
self._add_relatedstudent('student1', tags='good,bad')
self._add_relatedstudent('student2', tags='group1')
self._browseToManageStudentsAs('p1admin', self.period.id)
self.click_row_by_username('student1')
self.click_row_by_username('student2')
panel = self.click_tagbutton('clear')
cancelbutton = panel.find_element_by_css_selector('.cancelbutton')
self.waitForDisplayed(cancelbutton)
cancelbutton.click()
helpbox = self.getHelpBox()
self.waitForDisplayed(helpbox)
self.assertEquals(self.period.relatedstudent_set.get(user__username='******').tags,
'good,bad')
self.assertEquals(self.period.relatedstudent_set.get(user__username='******').tags,
'group1')
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 TestRestNodeDetails(TestCase):
def setUp(self):
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni:admin(uniadmin).inf:admin(infadmin)')
self.testhelper.add(nodes='uni.fys')
self.testhelper.create_superuser('super')
self.client = RestClient()
def _geturl(self, node_id):
return reverse('devilry_nodeadmin-rest_node_details', kwargs={'id': node_id})
def test_as_nobody(self):
self.testhelper.create_user('nobody')
self.client.login(username='******', password='******')
content, response = self.client.rest_get(self._geturl(self.testhelper.uni_inf.id))
self.assertEquals(response.status_code, 403)
def test_as_wrongadmin(self):
self.client.login(username='******', password='******')
content, response = self.client.rest_get(self._geturl(self.testhelper.uni_fys.id))
self.assertEquals(response.status_code, 403)
def _test_get_as(self, username):
self.client.login(username=username, password='******')
content, response = self.client.rest_get(self._geturl(self.testhelper.uni_inf.id))
self.assertEquals(response.status_code, 200)
self.assertEquals(set(content.keys()),
set([u'subject_count', u'short_name', u'id',
u'long_name', u'assignment_count', u'etag',
u'period_count', u'path', u'childnodes', u'subjects']))
self.assertEquals(content['short_name'], 'inf')
self.assertEquals(content['id'], self.testhelper.uni_inf.id)
def test_get_as_nodeadmin(self):
self._test_get_as('infadmin')
def test_get_as_superuser(self):
self._test_get_as('super')
def test_get_path_only_admin_on_child(self):
self.client.login(username='******', password='******')
content, response = self.client.rest_get(self._geturl(self.testhelper.uni_inf.id))
self.assertEquals(response.status_code, 200)
self.assertEquals(content['path'], [
{u'id': self.testhelper.uni_inf.id, u'short_name': u'uni.inf'}
])
def _test_get_path_toplevel_admin(self, username):
self.client.login(username=username, password='******')
content, response = self.client.rest_get(self._geturl(self.testhelper.uni_inf.id))
self.assertEquals(response.status_code, 200)
self.assertEquals(content['path'], [
{u'id': self.testhelper.uni.id, u'short_name': u'uni'},
{u'id': self.testhelper.uni_inf.id, u'short_name': u'inf'}
])
def test_get_path_toplevel_admin(self):
self._test_get_path_toplevel_admin('uniadmin')
def test_get_path_toplevel_superuser(self):
self._test_get_path_toplevel_admin('super')
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 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 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 TestGroupInfoUI(StudentSeleniumTestCase):
def setUp(self):
self.testhelper = TestHelper()
self.testhelper.create_user('student1')
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['p1:begins(-3):ends(10)'],
assignments=['a1:pub(1):ln(Assignment One)'])
self.fileinfo = {'ok.py': ['print ', 'meh']}
def _browseToGroup(self, groupid):
self.browseTo('/group/{groupid}/'.format(groupid=groupid))
def _browseToAddDelivery(self, groupid):
self.browseTo('/group/{groupid}/@@add-delivery'.format(groupid=groupid))
def test_doesnotexists(self):
self.login('student1')
self._browseToGroup(100000)
self.waitForCssSelector('.devilry_extjsextras_alertmessage')
self.assertTrue('Permission denied' in self.selenium.page_source)
def test_info(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1)')
self.login('student1')
self._browseToGroup(self.testhelper.sub_p1_a1_g1.id)
self.waitForCssSelector('.devilry_student_groupmetadata')
# Header
self.assertTrue('Assignment One' in self.selenium.page_source)
self.assertTrue('sub.p1.a1' in self.selenium.page_source)
# Group info
self.assertEquals(self.selenium.find_element_by_css_selector('.groupnameblock h3').text.strip(), 'Group name')
self.assertEquals(self.selenium.find_element_by_css_selector('.groupnameblock .groupname').text.strip(), 'g1')
self.assertEquals(self.selenium.find_element_by_css_selector('.candidatesblock').text.strip(), '')
self.assertEquals(self.selenium.find_element_by_css_selector('.examinersblock h3').text.strip(), 'Examiner')
self.assertEquals(self.selenium.find_element_by_css_selector('.examinersblock small').text.strip(), 'No examiner')
self.assertEquals(self.selenium.find_element_by_css_selector('.gradeblock h3').text.strip(), 'Grade')
self.assertEquals(self.selenium.find_element_by_css_selector('.gradeblock small').text.strip(), 'No feedback')
self.assertEquals(self.selenium.find_element_by_css_selector('.statusblock h3').text.strip(), 'Status')
self.assertEquals(self.selenium.find_element_by_css_selector('.statusblock .label-success').text.strip(), 'Open')
self.assertEquals(len(self.selenium.find_elements_by_css_selector('.deliveriesblock li')), 0)
self.assertEquals(self.selenium.find_element_by_css_selector('.adddeliveryblock').text.strip(), '')
def test_no_groupname(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1)')
self.login('student1')
self.testhelper.sub_p1_a1_g1.name = ''
self.testhelper.sub_p1_a1_g1.save()
self._browseToGroup(self.testhelper.sub_p1_a1_g1.id)
self.waitForCssSelector('.devilry_student_groupmetadata')
self.assertEquals(self.selenium.find_element_by_css_selector('.groupnameblock').text.strip(), '')
def test_no_deadlines(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1)')
self.login('student1')
self._browseToGroup(self.testhelper.sub_p1_a1_g1.id)
self.waitForCssSelector('.devilry_extjsextras_alertmessage')
self.assertTrue(self.selenium.find_element_by_css_selector('.devilry_extjsextras_alertmessage').text.strip().startswith('No deadlines'))
def test_userlists(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1,student2):examiner(examiner1,examiner2)')
self.testhelper.student1.devilryuserprofile.full_name = 'Student One'
self.testhelper.student1.devilryuserprofile.save()
self.login('student1')
self._browseToGroup(self.testhelper.sub_p1_a1_g1.id)
self.waitForCssSelector('.devilry_student_groupmetadata')
self.assertEquals(self.selenium.find_element_by_css_selector('.candidatesblock h3').text.strip(), 'Students')
candidatelinks = self.selenium.find_elements_by_css_selector('.candidatesblock li a')
self.assertEquals(len(candidatelinks), 2)
names = map(lambda c: c.text.strip(), candidatelinks)
self.assertEquals(set(names), set(['Student One', 'student2']))
self.assertEquals(self.selenium.find_element_by_css_selector('.examinersblock h3').text.strip(), 'Examiners')
examinerlinks = self.selenium.find_elements_by_css_selector('.examinersblock li a')
self.assertEquals(len(examinerlinks), 2)
names = map(lambda c: c.text.strip(), examinerlinks)
self.assertEquals(set(names), set(['examiner1', 'examiner2']))
def test_anonymous(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1)')
self.testhelper.sub_p1_a1.anonymous = True
self.testhelper.sub_p1_a1.save()
self.login('student1')
self._browseToGroup(self.testhelper.sub_p1_a1_g1.id)
self.waitForCssSelector('.devilry_student_groupmetadata')
self.assertEquals(self.selenium.find_element_by_css_selector('.examinersblock').text.strip(), '')
def test_hard_deadline_expired(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1).d1:ends(1)')
self.testhelper.sub_p1_a1.deadline_handling = 1 # Hard deadlines
self.testhelper.sub_p1_a1.save()
self.login('student1')
self._browseToGroup(self.testhelper.sub_p1_a1_g1.id)
self.waitForCssSelector('.devilry_student_groupmetadata')
self.assertEquals(self.selenium.find_element_by_css_selector('.statusblock h3').text.strip(), 'Status')
self.assertEquals(self.selenium.find_element_by_css_selector('.statusblock .label-important').text.strip(), 'Deadline expired')
self.assertEquals(self.selenium.find_element_by_css_selector('.adddeliveryblock').text.strip(), '')
def test_hard_deadline_not_expired(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1).d1:ends(1)')
self.testhelper.sub_p1_a1.deadline_handling = 1 # Hard deadlines
self.testhelper.sub_p1_a1.save()
deadline = self.testhelper.sub_p1_a1_g1_d1
deadline.deadline = datetime.now() + timedelta(days=2)
deadline.save()
self.login('student1')
self._browseToGroup(self.testhelper.sub_p1_a1_g1.id)
self.waitForCssSelector('.devilry_student_groupmetadata')
self.assertEquals(self.selenium.find_element_by_css_selector('.statusblock h3').text.strip(), 'Status')
self.assertEquals(self.selenium.find_element_by_css_selector('.statusblock .label-success').text.strip(), 'Open')
self.assertEquals(self.selenium.find_element_by_css_selector('.adddeliveryblock .add_delivery_link').text.strip(), 'Add delivery')
def _expand_deadline(self, deadline):
clickable = self.selenium.find_element_by_css_selector('#deadlinepanel-{0} .x-panel-header'.format(deadline.id))
clickable.click()
self.waitForCssSelector('#deadlinepanel-{0} .x-panel-body'.format(deadline.id))
return self.selenium.find_element_by_css_selector('#deadlinepanel-{0}'.format(deadline.id))
def test_no_feedback(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1):examiner(examiner1)')
self.testhelper.add_to_path('uni;sub.p1.a1.g1.d1')
delivery = self.testhelper.add_delivery('sub.p1.a1.g1', self.fileinfo)
self.login('student1')
self._browseToGroup(self.testhelper.sub_p1_a1_g1.id)
self.waitForCssSelector('.devilry_student_groupmetadata')
self.assertEquals(self.selenium.find_element_by_css_selector('.gradeblock small').text.strip(), 'No feedback')
self.assertEquals(self.selenium.find_element_by_css_selector('.statusblock .label-success').text.strip(), 'Open')
self.assertEquals(len(self.selenium.find_elements_by_css_selector('.deliveriesblock li')), 1)
deadlinepanel = self._expand_deadline(self.testhelper.sub_p1_a1_g1_d1)
deliverypanel = deadlinepanel.find_elements_by_css_selector('.devilry_student_groupinfo_delivery')[0]
self.assertEquals(deliverypanel.find_element_by_css_selector('.gradeblock').text.strip(), '')
self.assertEquals(deliverypanel.find_element_by_css_selector('.no_feedback').text.strip(), 'No feedback')
def test_passing_grade(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1):examiner(examiner1)')
self.testhelper.add_to_path('uni;sub.p1.a1.g1.d1')
delivery = self.testhelper.add_delivery('sub.p1.a1.g1', self.fileinfo)
self.testhelper.add_feedback(delivery, verdict={'grade': 'A', 'points': 10, 'is_passing_grade': True},
rendered_view='Good stuff')
self.login('student1')
self._browseToGroup(self.testhelper.sub_p1_a1_g1.id)
self.waitForCssSelector('.devilry_student_groupmetadata')
self.assertEquals(self.selenium.find_element_by_css_selector('.gradeblock .success').text.strip(), 'Passed')
self.assertEquals(self.selenium.find_element_by_css_selector('.gradeblock small').text.strip(), '(A)')
self.assertEquals(self.selenium.find_element_by_css_selector('.statusblock .label-warning').text.strip(), 'Closed')
self.assertEquals(len(self.selenium.find_elements_by_css_selector('.deliveriesblock li')), 1)
deadlinepanel = self._expand_deadline(self.testhelper.sub_p1_a1_g1_d1)
deliverypanel = deadlinepanel.find_elements_by_css_selector('.devilry_student_groupinfo_delivery')[0]
self.assertEquals(deliverypanel.find_element_by_css_selector('.gradeblock h4').text.strip(), 'Grade')
self.assertEquals(deliverypanel.find_element_by_css_selector('.gradeblock .success').text.strip(), 'Passed')
self.assertEquals(deliverypanel.find_element_by_css_selector('.gradeblock small').text.strip(), '(A)')
self.assertEquals(deliverypanel.find_element_by_css_selector('.feedback_rendered_view').text.strip(), 'Good stuff')
def test_failing_grade(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1):examiner(examiner1)')
self.testhelper.add_to_path('uni;sub.p1.a1.g1.d1')
delivery = self.testhelper.add_delivery('sub.p1.a1.g1', self.fileinfo)
self.testhelper.add_feedback(delivery, verdict={'grade': 'F', 'points': 2, 'is_passing_grade': False},
rendered_view='Bad stuff')
self.login('student1')
self._browseToGroup(self.testhelper.sub_p1_a1_g1.id)
self.waitForCssSelector('.devilry_student_groupmetadata')
self.assertEquals(self.selenium.find_element_by_css_selector('.gradeblock .danger').text.strip(), 'Failed')
self.assertEquals(self.selenium.find_element_by_css_selector('.gradeblock small').text.strip(), '(F)')
self.assertEquals(self.selenium.find_element_by_css_selector('.statusblock .label-warning').text.strip(), 'Closed')
self.assertEquals(len(self.selenium.find_elements_by_css_selector('.deliveriesblock li')), 1)
deadlinepanel = self._expand_deadline(self.testhelper.sub_p1_a1_g1_d1)
deliverypanel = deadlinepanel.find_elements_by_css_selector('.devilry_student_groupinfo_delivery')[0]
self.assertEquals(deliverypanel.find_element_by_css_selector('.gradeblock h4').text.strip(), 'Grade')
self.assertEquals(deliverypanel.find_element_by_css_selector('.gradeblock .danger').text.strip(), 'Failed')
self.assertEquals(deliverypanel.find_element_by_css_selector('.gradeblock small').text.strip(), '(F)')
self.assertEquals(deliverypanel.find_element_by_css_selector('.feedback_rendered_view').text.strip(), 'Bad stuff')
def test_deliverieslist(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1):examiner(examiner1)')
self.testhelper.add_to_path('uni;sub.p1.a1.g1.d1')
self.testhelper.add_delivery('sub.p1.a1.g1', self.fileinfo)
self.testhelper.add_delivery('sub.p1.a1.g1', self.fileinfo)
self.testhelper.add_delivery('sub.p1.a1.g1', self.fileinfo)
self.login('student1')
self._browseToGroup(self.testhelper.sub_p1_a1_g1.id)
self.waitForCssSelector('.devilry_student_groupmetadata')
self.assertEquals(len(self.selenium.find_elements_by_css_selector('.deliveriesblock li')), 3)
def test_deadlinetext(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1):examiner(examiner1)')
self.testhelper.add_to_path('uni;sub.p1.a1.g1.d1')
deadline = self.testhelper.sub_p1_a1_g1_d1
deadline.text = 'This is a test'
deadline.save()
self.login('student1')
self._browseToGroup(self.testhelper.sub_p1_a1_g1.id)
self.waitForCssSelector('.devilry_student_groupmetadata')
deadlinepanel = self._expand_deadline(self.testhelper.sub_p1_a1_g1_d1)
self.assertEquals(deadlinepanel.find_element_by_css_selector('.deadlinetext h2').text.strip(),
'About this deadline')
deadlinetextpara = deadlinepanel.find_element_by_css_selector('.deadlinetext p')
self.assertEquals(deadlinetextpara.text.strip(), 'This is a test')
self.assertEquals(deadlinetextpara.get_attribute('style').strip(), 'white-space: pre-wrap;')
def test_no_deadlinetext(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1):examiner(examiner1)')
self.testhelper.add_to_path('uni;sub.p1.a1.g1.d1')
self.login('student1')
self._browseToGroup(self.testhelper.sub_p1_a1_g1.id)
self.waitForCssSelector('.devilry_student_groupmetadata')
deadlinepanel = self._expand_deadline(self.testhelper.sub_p1_a1_g1_d1)
self.assertEquals(deadlinepanel.find_element_by_css_selector('.deadlinetext').text.strip(), '')
def test_non_electronic(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1):examiner(examiner1)')
self.testhelper.sub_p1_a1.delivery_types = NON_ELECTRONIC
self.testhelper.sub_p1_a1.save()
self.testhelper.add_to_path('uni;sub.p1.a1.g1.d1')
delivery = self.testhelper.add_delivery('sub.p1.a1.g1', self.fileinfo)
self.testhelper.add_feedback(delivery, verdict={'grade': 'F', 'points': 2, 'is_passing_grade': False},
rendered_view='Bad stuff')
self.login('student1')
self._browseToGroup(self.testhelper.sub_p1_a1_g1.id)
self.waitForCssSelector('.devilry_student_groupmetadata')
self.assertEquals(self.selenium.find_element_by_css_selector('.gradeblock .danger').text.strip(), 'Failed')
self.assertEquals(self.selenium.find_element_by_css_selector('.gradeblock small').text.strip(), '(F)')
self.assertEquals(self.selenium.find_element_by_css_selector('.statusblock .label-warning').text.strip(), 'Closed')
self.assertEquals(len(self.selenium.find_elements_by_css_selector('.deliveriesblock li')), 1)
deadlinepanel = self._expand_deadline(self.testhelper.sub_p1_a1_g1_d1)
deliverypanel = deadlinepanel.find_elements_by_css_selector('.devilry_student_groupinfo_delivery')[0]
for selector in ('.timeofdeliveryblock', '.deliverymadebyblock', '.fileblock'):
self.assertEquals(len(deliverypanel.find_elements_by_css_selector(selector)), 0)
self.assertEquals(deliverypanel.find_element_by_css_selector('.gradeblock h4').text.strip(), 'Grade')
self.assertEquals(deliverypanel.find_element_by_css_selector('.gradeblock .danger').text.strip(), 'Failed')
self.assertEquals(deliverypanel.find_element_by_css_selector('.gradeblock small').text.strip(), '(F)')
self.assertEquals(deliverypanel.find_element_by_css_selector('.rendered_view').text.strip(), 'Bad stuff')
self.assertEquals(deliverypanel.find_element_by_css_selector('.activefeedbackblock h4').text.strip(), 'Active feedback')
class TestGroupManager(TestCase, GroupManagerTestMixin):
def setUp(self):
self.client = RestClient()
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['p1'],
assignments=['a1'])
self.a1id = self.testhelper.sub_p1_a1.id
self.testhelper.create_user('user1')
self.testhelper.create_user('user2')
self.testhelper.create_user('user3')
def test_update_group(self):
self.assertEquals(AssignmentGroup.objects.all().count(), 0)
manager = GroupManager(self.a1id)
self.assertEquals(manager.group.id, None)
manager.update_group(name='Nametest', is_open=False)
self.assertIsNotNone(manager.group.id)
self.assertEquals(manager.group.name, 'Nametest')
self.assertEquals(manager.group.is_open, False)
self.assertEquals(AssignmentGroup.objects.all().count(), 1)
def test_existinggroup(self):
self.testhelper.add_to_path('uni;sub.p1.a1.g1')
manager = GroupManager(self.a1id, self.testhelper.sub_p1_a1_g1.id)
self.assertEquals(manager.group.id, self.testhelper.sub_p1_a1_g1.id)
with self.assertRaises(AssignmentGroup.DoesNotExist):
GroupManager(self.a1id, 10000000)
with self.assertRaises(AssignmentGroup.DoesNotExist):
GroupManager(10000000, self.testhelper.sub_p1_a1_g1.id)
#
# Examiners
#
def test_update_examiners_create(self):
manager = GroupManager(self.a1id)
manager.group.save()
manager.update_examiners([self.create_examinerdict(username='******')])
examiners = manager.get_group_from_db().examiners.all()
self.assertEquals(len(examiners), 1)
created = examiners[0]
self.assertEquals(created.user.id, self.testhelper.user1.id)
manager.update_examiners([self.create_examinerdict(id=created.id),
self.create_examinerdict(username='******')])
examiners = manager.get_group_from_db().examiners.all()
self.assertEquals(len(examiners), 2)
ids = [examiner.id for examiner in examiners]
self.assertEquals(set(ids),
set([self.testhelper.user1.id, self.testhelper.user2.id]))
def test_update_examiners_create_duplicate(self):
manager = GroupManager(self.a1id)
manager.group.save()
manager.group.examiners.create(user=self.testhelper.user1)
with self.assertRaises(ValidationError):
manager.update_examiners([self.create_examinerdict(username='******')])
def test_update_examiners_delete(self):
manager = GroupManager(self.a1id)
manager.group.save()
manager.group.examiners.create(user=self.testhelper.user1)
manager.group.examiners.create(user=self.testhelper.user2)
manager.update_examiners([])
examiners = manager.get_group_from_db().examiners.all()
self.assertEquals(len(examiners), 0)
def test_update_examiners_complex(self):
manager = GroupManager(self.a1id)
manager.group.save()
manager.group.examiners.create(user=self.testhelper.user1)
manager.group.examiners.create(user=self.testhelper.user2)
manager.update_examiners([self.create_examinerdict(id=self.testhelper.user1.id), # keep user1
# ... delete user2
self.create_examinerdict(username='******')]) # create user3
examiners = manager.get_group_from_db().examiners.all()
self.assertEquals(len(examiners), 2)
ids = [examiner.id for examiner in examiners]
self.assertEquals(set(ids),
set([self.testhelper.user1.id, self.testhelper.user3.id]))
#
# Candidates
#
def test_update_candidates_create(self):
manager = GroupManager(self.a1id)
manager.group.save()
manager.update_candidates([self.create_candidatedict(username='******')])
candidates = manager.get_group_from_db().candidates.all()
self.assertEquals(len(candidates), 1)
created = candidates[0]
self.assertEquals(created.student.id, self.testhelper.user1.id)
self.assertEquals(created.candidate_id, None)
manager.update_candidates([self.create_candidatedict(id=created.id),
self.create_candidatedict(username='******')])
candidates = manager.get_group_from_db().candidates.all()
self.assertEquals(len(candidates), 2)
ids = [candidate.id for candidate in candidates]
self.assertEquals(set(ids),
set([self.testhelper.user1.id, self.testhelper.user2.id]))
def test_update_candidates_create_candidate_id(self):
manager = GroupManager(self.a1id)
manager.group.save()
manager.update_candidates([self.create_candidatedict(username='******',
candidate_id='secret')])
candidates = manager.get_group_from_db().candidates.all()
created = candidates[0]
self.assertEquals(created.candidate_id, 'secret')
def test_update_candidates_create_duplicate_allowed(self):
manager = GroupManager(self.a1id)
manager.group.save()
manager.group.candidates.create(student=self.testhelper.user1)
manager.update_candidates([self.create_candidatedict(username='******')]) # Does not raise exception
def test_update_candidates_delete(self):
manager = GroupManager(self.a1id)
manager.group.save()
manager.group.candidates.create(student=self.testhelper.user1)
manager.group.candidates.create(student=self.testhelper.user2)
manager.update_candidates([])
candidates = manager.get_group_from_db().candidates.all()
self.assertEquals(len(candidates), 0)
def test_update_candidates_complex(self):
manager = GroupManager(self.a1id)
manager.group.save()
manager.group.candidates.create(student=self.testhelper.user1)
manager.group.candidates.create(student=self.testhelper.user2)
manager.update_candidates([self.create_candidatedict(id=self.testhelper.user1.id), # keep user1
# ... delete user2
self.create_candidatedict(username='******')]) # create user3
candidates = manager.get_group_from_db().candidates.all()
self.assertEquals(len(candidates), 2)
ids = [candidate.id for candidate in candidates]
self.assertEquals(set(ids),
set([self.testhelper.user1.id, self.testhelper.user3.id]))
#
# Tags
#
def test_update_tags(self):
manager = GroupManager(self.a1id)
manager.group.save()
manager.update_tags([self.create_tagdict('mytag')])
tags = manager.get_group_from_db().tags.all()
self.assertEquals(len(tags), 1)
created = tags[0]
self.assertEquals(created.tag, 'mytag')
manager.update_tags([self.create_tagdict('tag1'),
self.create_tagdict('tag2')])
tagsObjs = manager.get_group_from_db().tags.all()
self.assertEquals(len(tagsObjs), 2)
tags = [tagObj.tag for tagObj in tagsObjs]
self.assertEquals(set(tags), set(['tag1', 'tag2']))
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 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)
