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 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 TestInstanceGroupRest(TestCase, GroupManagerTestMixin):
def setUp(self):
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['p1'],
assignments=['a1:admin(a1admin)'])
self.client = RestClient()
self.testhelper.create_superuser('grandma')
self.testhelper.create_user('candidate1')
self.testhelper.create_user('examiner1')
self.testhelper.create_superuser('superuser')
self.a1id = self.testhelper.sub_p1_a1.id
def _geturl(self, assignment_id, group_id):
return '/devilry_subjectadmin/rest/group/{0}/{1}'.format(assignment_id, group_id)
def _putas(self, username, assignment_id, group_id, data={}):
self.client.login(username=username, password='******')
return self.client.rest_put(self._geturl(assignment_id, group_id), data)
def _add_group(self, name, candidates, examiners):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate({candidates}):examiner({examiners})'.format(**vars()))
return getattr(self.testhelper, 'sub_p1_a1_' + name)
def test_put_minimal(self):
group = self._add_group('g1', candidates='candidate1', examiners='examiner1')
self.assertEquals(group.name, 'g1')
self.assertEquals(group.is_open, True)
data = {'name': 'changed',
'is_open': False}
content, response = self._putas('a1admin', self.a1id, group.id, data)
self.assertEquals(response.status_code, 200)
self.assertEquals(set(content.keys()),
set(['name', 'id', 'etag', 'is_open', 'parentnode',
'feedback', 'deadlines', 'candidates', 'tags',
'examiners', 'num_deliveries']))
self.assertEquals(content['name'], 'changed')
self.assertEquals(content['is_open'], False)
self.assertEquals(content['parentnode'], self.a1id)
self.assertEquals(content['num_deliveries'], 0)
self.assertEquals(content['feedback'], None)
self.assertEquals(content['deadlines'], [])
self.assertEquals(content['candidates'], [])
self.assertEquals(content['examiners'], [])
self.assertEquals(content['tags'], [])
groups = self.testhelper.sub_p1_a1.assignmentgroups.all()
self.assertEquals(len(groups), 1)
self.assertEquals(content['id'], groups[0].id)
def _test_put_as(self, username):
group = self._add_group('g1', candidates='candidate2', examiners='examiner2')
data = {'name': 'changed',
'is_open': False,
'examiners': [self.create_examinerdict(username='******')],
'candidates': [self.create_candidatedict(username='******')],
'tags': [self.create_tagdict('mytag')]}
content, response = self._putas(username, self.a1id, group.id, data)
#from pprint import pprint
#print 'Response content:'
#pprint(content)
self.assertEquals(response.status_code, 200)
self.assertEquals(content['name'], 'changed')
self.assertEquals(content['is_open'], False)
self.assertEquals(content['parentnode'], self.a1id)
self.assertEquals(content['num_deliveries'], 0)
# Feedback
self.assertEquals(content['feedback'], None)
# Deadlines
self.assertEquals(content['deadlines'], [])
# Tags
self.assertEquals(len(content['tags']), 1)
tag = content['tags'][0]
self.assertEquals(tag['tag'], 'mytag')
self.assertEquals(set(tag.keys()), set(['id', 'tag']))
# Examiners
self.assertEquals(len(content['examiners']), 1)
examiner = content['examiners'][0]
self.assertEquals(set(examiner.keys()),
set(['id', 'user']))
self.assertEquals(set(examiner['user'].keys()),
set(['email', 'full_name', 'id', 'username']))
self.assertEquals(examiner['user']['id'], self.testhelper.examiner1.id)
self.assertEquals(examiner['user']['username'], 'examiner1')
# Candidates
self.assertEquals(len(content['candidates']), 1)
candidate = content['candidates'][0]
self.assertEquals(set(candidate.keys()),
set(['id', 'user', 'candidate_id']))
self.assertEquals(set(candidate['user'].keys()),
set(['email', 'full_name', 'id', 'username']))
self.assertEquals(candidate['user']['id'], self.testhelper.candidate1.id)
self.assertEquals(candidate['candidate_id'], '')
self.assertEquals(candidate['user']['username'], 'candidate1')
# It was actually updated?
group = self.testhelper.sub_p1_a1.assignmentgroups.get(id=group.id)
self.assertEquals(group.name, 'changed')
def test_put_as_superuser(self):
self._test_put_as('superuser')
def test_put_as_assignmentadmin(self):
self._test_put_as('a1admin')
def test_put_doesnotexist(self):
data = {'name': 'changed',
'is_open': False}
content, response = self._putas('grandma', 10000, 100000, data)
self.assertEquals(response.status_code, 404)
def test_put_denied(self):
self.testhelper.create_user('nobody')
self.testhelper.add_to_path('uni;sub.p1.a1.g1')
group = self.testhelper.sub_p1_a1_g1
data = {'name': 'changed',
'is_open': False}
content, response = self._putas('nobody', self.a1id, group.id, data)
self.assertEquals(response.status_code, 403)
def test_put_ro_fields(self):
group = self._add_group('g1', candidates='candidate1', examiners='examiner1')
self.assertEquals(group.name, 'g1')
self.assertEquals(group.is_open, True)
data = {'name': 'changed',
'is_open': False,
'feedback': 'should be ignored',
'id': 'should be ignored',
'num_deliveries': 'should be ignored',
'deadlines': 'should be ignored'}
content, response = self._putas('a1admin', self.a1id, group.id, data)
self.assertEquals(response.status_code, 200)
#
# GET
#
def _getas(self, username, assignment_id, group_id):
self.client.login(username=username, password='******')
return self.client.rest_get(self._geturl(assignment_id, group_id))
def _test_get_as(self, username):
self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(candidate1):examiner(examiner1).d1:ends(5)')
self.testhelper.add_to_path('uni;sub.p1.a1.g1.d2:ends(10)')
group = self.testhelper.sub_p1_a1_g1
content, response = self._getas(username, self.a1id, group.id)
#from pprint import pprint
#print 'Response content:'
#pprint(content)
self.assertEquals(response.status_code, 200)
self.assertEquals(set(content.keys()),
set(['name', 'id', 'etag', 'is_open', 'parentnode',
'feedback', 'deadlines', 'candidates', 'tags',
'examiners', 'num_deliveries']))
self.assertEquals(content['name'], 'g1')
self.assertEquals(content['is_open'], True)
self.assertEquals(content['parentnode'], self.a1id)
self.assertEquals(content['num_deliveries'], 0)
self.assertEquals(content['feedback'], None)
# Deadlines
self.assertEquals(len(content['deadlines']), 2)
self.assertEquals(set(content['deadlines'][0].keys()),
set(['id', 'deadline']))
# Candidates
self.assertEquals(len(content['candidates']), 1)
candidate = content['candidates'][0]
self.assertEquals(candidate['candidate_id'], None)
self.assertEquals(candidate['user'], {'id': self.testhelper.candidate1.id,
'username': '******',
'email': '*****@*****.**',
'full_name': None})
# Examiners
self.assertEquals(len(content['examiners']), 1)
examiner = content['examiners'][0]
self.assertEquals(examiner['user'], {'id': self.testhelper.examiner1.id,
'username': '******',
'email': '*****@*****.**',
'full_name': None})
def test_get_as_assignmentadmin(self):
self._test_get_as('a1admin')
def test_get_as_superuser(self):
self._test_get_as('superuser')
def test_get_denied(self):
self.testhelper.create_user('nobody')
self.testhelper.add_to_path('uni;sub.p1.a1.g1')
group = self.testhelper.sub_p1_a1_g1
content, response = self._getas('nobody', self.a1id, group.id)
self.assertEquals(response.status_code, 403)
class TestRestPassedInPreviousPeriod(TransactionTestCase):
def setUp(self):
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['old:begins(-14):ends(6)', # 14 months ago
'cur:begins(-2)'], # 2 months ago
assignments=['a1:admin(adm):pub(0)']) # 0 days after period begins
self.client = RestClient()
self.url = '/devilry_subjectadmin/rest/passedinpreviousperiod/{0}'.format(self.testhelper.sub_cur_a1.id)
def _getas(self, username, **data):
self.client.login(username=username, password='******')
return self.client.rest_get(self.url, **data)
def _test_get_simple_as(self, username):
self.testhelper.add_to_path('uni;sub.cur.a1.g1:candidate(student1)')
content, response = self._getas(username)
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 1)
item = content[0]
self.assertEquals(item['group']['id'], self.testhelper.sub_cur_a1_g1.id)
self.assertEquals(item['oldgroup'], None)
self.assertEquals(item['whyignored'], 'not_in_previous')
def test_get_simple_as_assignmentadmin(self):
self._test_get_simple_as('adm')
def test_get_simple_as_superuser(self):
self.testhelper.create_superuser('super')
self._test_get_simple_as('super')
def test_get_as_nobody(self):
self.testhelper.create_user('nobody')
content, response = self._getas('nobody')
self.assertEquals(response.status_code, 403)
def test_with_oldfeedback(self):
# Add a group for the student on the old period
self.testhelper.add_to_path('uni;sub.old.a1.g1:candidate(student1):examiner(examiner1).d1:ends(1)')
self.testhelper.create_feedbacks(
(self.testhelper.sub_old_a1_g1, {'grade': 'approved', 'points': 1, 'is_passing_grade': True})
)
# Add the student to the current period
self.testhelper.add_to_path('uni;sub.cur.a1.g1:candidate(student1)')
content, response = self._getas('adm')
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 1)
item = content[0]
self.assertEquals(item['group']['id'], self.testhelper.sub_cur_a1_g1.id)
self.assertEquals(item['whyignored'], None)
self.assertNotEquals(item['oldgroup'], None)
oldgroup = item['oldgroup']
self.assertEqual(oldgroup['id'], self.testhelper.sub_old_a1_g1.id)
self.assertEqual(oldgroup['assignment']['id'], self.testhelper.sub_old_a1.id)
self.assertEqual(oldgroup['period']['id'], self.testhelper.sub_old.id)
self.assertEqual(oldgroup['feedback_shortformat'], 'true')
def _putas(self, username, data):
self.client.login(username=username, password='******')
return self.client.rest_put(self.url, data)
def _test_putas(self, username):
self.testhelper.add_to_path('uni;sub.cur.a1.g1:candidate(student1).d1')
self.testhelper.add_to_path('uni;sub.cur.a1.g2:candidate(student2).d1')
self.testhelper.add_to_path('uni;sub.cur.a1.g3:candidate(student3).d1')
self.testhelper.add_to_path('uni;sub.old.a1.g3:candidate(student3):examiner(examiner1).d1')
oldg3_delivery = self.testhelper.add_delivery(self.testhelper.sub_old_a1_g3)
self.testhelper.add_feedback(oldg3_delivery,
verdict=dict(grade='C', points=40,
is_passing_grade=True))
g1 = self.testhelper.sub_cur_a1_g1
g2 = self.testhelper.sub_cur_a1_g2
g3 = self.testhelper.sub_cur_a1_g3
content, response = self._putas(username,
[{'id': g1.id,
'newfeedback_shortformat': 'true'},
{'id': g3.id,
'newfeedback_shortformat': 'true'}])
self.assertEquals(response.status_code, 200)
g1 = self.testhelper.reload_from_db(g1)
self.assertEquals(g1.feedback.grade, 'approved')
self.assertEquals(g1.feedback.delivery.delivery_type, deliverytypes.ALIAS)
g2 = self.testhelper.reload_from_db(g2)
self.assertEquals(g2.feedback, None)
g3 = self.testhelper.reload_from_db(g3)
self.assertEquals(g3.feedback.grade, 'approved')
self.assertEquals(g3.feedback.delivery.delivery_type, deliverytypes.ALIAS)
self.assertEquals(g3.feedback.delivery.alias_delivery, oldg3_delivery)
def test_put_as_assignmentadmin(self):
self._test_putas('adm')
def test_put_as_superuser(self):
self.testhelper.create_superuser('super')
self._test_putas('super')
def test_put_as_nobody(self):
self.testhelper.create_user('nobody')
content, response = self._putas('nobody', [])
self.assertEquals(response.status_code, 403)
def test_put_shortformat_validationerror(self):
self.testhelper.add_to_path('uni;sub.cur.a1.g1:candidate(student1).d1')
g1 = self.testhelper.sub_cur_a1_g1
content, response = self._putas('adm',
[{'id': g1.id,
'newfeedback_shortformat': 'invalidstuff'}])
self.assertEquals(response.status_code, 400)
self.assertEquals(content['errors'][0], u'Must be one of: true, false.')
class TestRestDeadlinesBulkUpdateReadOrDelete(TestCase):
def setUp(self):
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['p1:begins(-2)']) # 2 months ago
self.testhelper.sub_p1.start_time = datetime(2000, 1, 1, 22, 30, 49)
self.testhelper.sub_p1.save()
self.testhelper.add_to_path('uni;sub.p1.a1:admin(adm):pub(0)') # 0 days after period begins + 2 sec
self.client = RestClient()
for groupnum in xrange(3):
# deadline 5 days after assignment starts
self.testhelper.add_to_path('uni;sub.p1.a1.g{0}:candidate(cand1):examiner(exam1).d1:ends(5)'.format(groupnum))
def _geturl(self, deadline=None):
deadline = deadline or self.testhelper.sub_p1_a1_g1_d1
bulkdeadline_id = encode_bulkdeadline_id(deadline)
return '/devilry_subjectadmin/rest/deadlinesbulk/{0}/{1}'.format(self.testhelper.sub_p1_a1.id,
bulkdeadline_id)
def test_encode_unique_bulkdeadline_id(self):
d = Deadline(deadline=datetime(2000, 12, 24, 22, 30, 49))
self.assertEquals(encode_bulkdeadline_id(d),
'2000-12-24T22_30_49--')
d.text = 'Hello world'
self.assertEquals(encode_bulkdeadline_id(d),
'2000-12-24T22_30_49--{0}'.format(sha1hash('Hello world')))
# Ensure unicode works
d.text = u'\u00e5ello world'
self.assertEquals(encode_bulkdeadline_id(d),
'2000-12-24T22_30_49--{0}'.format(sha1hash(u'\u00e5ello world')))
def test_decode_unique_bulkdeadline_id(self):
self.assertEquals(decode_bulkdeadline_id('2000-12-24T22_30_49--'),
(datetime(2000, 12, 24, 22, 30, 49), ''))
self.assertEquals(decode_bulkdeadline_id('2000-12-24T22_30_49--{0}'.format(sha1hash('Hello world'))),
(datetime(2000, 12, 24, 22, 30, 49), sha1hash('Hello world')))
def _putas(self, username, data):
self.client.login(username=username, password='******')
return self.client.rest_put(self._geturl(), data)
def test_put(self):
self.assertEquals(self.testhelper.sub_p1_a1.publishing_time, datetime(2000, 1, 1, 22, 30, 51))
self.assertEquals(self.testhelper.sub_p1_a1_g1_d1.deadline,
datetime(2000, 1, 1, 22, 30) + timedelta(days=5))
new_deadline = datetime(2004, 12, 24, 20, 30)
content, response = self._putas('adm', {'deadline': format_datetime(new_deadline),
'text': 'Hello'})
self.assertEquals(response.status_code, 200)
self.assertEquals(decode_bulkdeadline_id(content['bulkdeadline_id'])[0],
new_deadline)
self.assertEquals(len(content['groups']), 3)
self.assertEquals(content['text'], 'Hello')
self.assertEquals(content['deadline'], format_datetime(new_deadline))
for groupnum in xrange(3):
deadline_id = getattr(self.testhelper, 'sub_p1_a1_g{0}_d1'.format(groupnum)).id
deadline = Deadline.objects.get(id=deadline_id)
self.assertEquals(deadline.deadline, new_deadline)
self.assertEquals(deadline.text, 'Hello')
def test_put_nonetext(self):
self.assertEquals(self.testhelper.sub_p1_a1.publishing_time, datetime(2000, 1, 1, 22, 30, 51))
self.assertEquals(self.testhelper.sub_p1_a1_g1_d1.deadline,
datetime(2000, 1, 1, 22, 30) + timedelta(days=5))
new_deadline = datetime(2004, 12, 24, 20, 30)
content, response = self._putas('adm', {'deadline': format_datetime(new_deadline),
'text': None})
self.assertEquals(response.status_code, 200)
for groupnum in xrange(3):
deadline_id = getattr(self.testhelper, 'sub_p1_a1_g{0}_d1'.format(groupnum)).id
deadline = Deadline.objects.get(id=deadline_id)
self.assertEquals(deadline.deadline, new_deadline)
self.assertEquals(deadline.text, '')
def test_put_before_publishingtime(self):
new_deadline = datetime(1990, 1, 1, 20, 30, 40)
content, response = self._putas('adm', {'deadline': format_datetime(new_deadline),
'text': None})
self.assertEquals(response.status_code, 400)
self.assertEquals(content['errors'], ['Deadline cannot be before publishing time.'])
def test_put_nobody(self):
self.testhelper.create_user('nobody')
content, response = self._putas('nobody', {})
self.assertEquals(response.status_code, 403)
def test_put_with_bulkdeadline_id(self):
new_deadline = datetime(2004, 12, 24, 20, 30)
content, response = self._putas('adm', {'deadline': format_datetime(new_deadline),
'bulkdeadline_id': 'ignored'})
self.assertEquals(response.status_code, 200)
def test_put_group_ids(self):
new_deadline = datetime(2004, 12, 24, 20, 30)
g1 = self.testhelper.sub_p1_a1_g1
g2 = self.testhelper.sub_p1_a1_g2
self.assertEquals(g1.deadlines.count(), 1)
content, response = self._putas('adm', {'deadline': format_datetime(new_deadline),
'text': 'Updated',
'group_ids': [g1.id, g2.id]})
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content['groups']), 2)
group_ids = set([g['id'] for g in content['groups']])
self.assertEquals(group_ids, set([g1.id, g2.id]))
for group in g1, g2:
group = self.testhelper.reload_from_db(group)
self.assertEquals(group.deadlines.count(), 1)
deadline = group.deadlines.all()[0]
self.assertEquals(deadline.deadline, new_deadline)
self.assertEquals(deadline.text, 'Updated')
def _getas(self, username, **data):
self.client.login(username=username, password='******')
return self.client.rest_get(self._geturl(), **data)
def test_get(self):
content, response = self._getas('adm')
self.assertEquals(response.status_code, 200)
self.assertEquals(decode_bulkdeadline_id(content['bulkdeadline_id'])[0],
self.testhelper.sub_p1_a1_g1_d1.deadline)
self.assertEquals(content['deadline'],
format_datetime(self.testhelper.sub_p1_a1_g1_d1.deadline))
self.assertEquals(content['text'], None)
self.assertEquals(len(content['groups']), 3)
def test_get_nobody(self):
self.testhelper.create_user('nobody')
content, response = self._getas('nobody')
self.assertEquals(response.status_code, 403)
def _deleteas(self, username, deadline=None):
self.client.login(username=username, password='******')
return self.client.rest_delete(self._geturl(deadline))
def test_delete_sanity(self):
# Test that the deadline method actually does what it is supposed to do (only deletes what it should delete)
new_deadline = datetime(2004, 12, 24, 20, 30)
created_deadline = None
for groupnum in xrange(2):
group = getattr(self.testhelper, 'sub_p1_a1_g{0}'.format(groupnum))
self.assertEquals(1, group.deadlines.count())
created_deadline = group.deadlines.create(deadline=new_deadline) # NOTE: Does not matter which deadline object we user, since we only need the datetime and text to generate bulkdeadline_id
self.assertEquals(2, group.deadlines.count())
self.testhelper.sub_p1_a1_g2.deadlines.create(deadline=datetime(2006, 12, 24, 20, 30))
self.testhelper.create_superuser('superuser')
content, response = self._deleteas('superuser', deadline=created_deadline)
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content['deleted_deadline_ids']), 2)
self.assertEquals(1, self.testhelper.sub_p1_a1_g0.deadlines.count())
self.assertEquals(1, self.testhelper.sub_p1_a1_g1.deadlines.count())
self.assertEquals(2, self.testhelper.sub_p1_a1_g2.deadlines.count())
def test_delete_with_content_as_superuser(self):
self.testhelper.create_superuser('superuser')
self.testhelper.add_delivery('sub.p1.a1.g1', {'bad.py': ['print ', 'bah']})
self.testhelper.add_feedback('sub.p1.a1.g1', verdict={'grade': 'F', 'points': 30, 'is_passing_grade': False})
content, response = self._deleteas('superuser')
self.assertEquals(response.status_code, 200)
def test_delete_with_content_as_assignmentadm(self):
self.testhelper.add_delivery('sub.p1.a1.g1', {'bad.py': ['print ', 'bah']})
self.testhelper.add_feedback('sub.p1.a1.g1', verdict={'grade': 'F', 'points': 30, 'is_passing_grade': False})
content, response = self._deleteas('adm')
self.assertEquals(response.status_code, 403)
def test_delete_without_content_as_assignmentadm(self):
content, response = self._deleteas('adm')
self.assertEquals(response.status_code, 200)
def test_delete_as_nobody(self):
self.testhelper.create_user('nobody')
content, response = self._deleteas('nobody')
self.assertEquals(response.status_code, 403)
class TestInstanceRelatedUserMixin(object):
def setUp(self):
self.client = RestClient()
self.testhelper = TestHelper()
self.testhelper.add(nodes="uni", subjects=["sub"], periods=["p1:admin(p1admin)", "p2:admin(p2admin)"])
self.testhelper.create_superuser("superuser")
self.testreluser = self.create_reluser_on_p1("testuser", tags="group1,group2")
def create_reluser_on_p1(self, username, tags):
raise NotImplementedError()
def get_url(self, periodid, reluserid):
raise NotImplementedError()
def get_valid_putdata(self):
return {"period": self.testhelper.sub_p1.id, "tags": "group10,group20", "user": self.testhelper.testuser.id}
def _getas(self, username, periodid, id, **data):
self.client.login(username=username, password="******")
return self.client.rest_get(self.get_url(periodid, id), **data)
def test_get_404(self):
content, response = self._getas("p1admin", self.testhelper.sub_p1.id, 40000000)
self.assertEquals(response.status_code, 404)
def test_get_unauthorized(self):
content, response = self._getas("p2admin", self.testhelper.sub_p1.id, self.testreluser.id)
self.assertEquals(response.status_code, 403)
def test_get_superuser(self):
content, response = self._getas("superuser", self.testhelper.sub_p1.id, self.testreluser.id)
self.assertEquals(response.status_code, 200)
def _putas(self, username, periodid, id, data):
self.client.login(username=username, password="******")
return self.client.rest_put(self.get_url(periodid, id), data)
def test_put_unauthorized(self):
content, response = self._putas(
"p2admin", self.testhelper.sub_p1.id, self.testreluser.id, self.get_valid_putdata()
)
self.assertEquals(response.status_code, 403)
def test_put_superuser(self):
content, response = self._putas(
"superuser", self.testhelper.sub_p1.id, self.testreluser.id, self.get_valid_putdata()
)
self.assertEquals(response.status_code, 200)
def test_put(self):
content, response = self._putas(
"p1admin", self.testhelper.sub_p1.id, self.testreluser.id, self.get_valid_putdata()
)
self.assertEquals(response.status_code, 200)
self.assertEquals(content["period"], self.testhelper.sub_p1.id)
self.assertEquals(content["tags"], "group10,group20")
self.assertEquals(set(content["user"].keys()), set(["email", "full_name", "id", "username"]))
self.assertEquals(content["user"]["id"], self.testreluser.user.id)
self.assertEquals(content["user"]["username"], "testuser")
return content
def _deleteas(self, username, periodid, id):
self.client.login(username=username, password="******")
return self.client.rest_delete(self.get_url(periodid, id))
def test_delete(self):
reluserid = self.testreluser.id
self.assertEquals(self.modelcls.objects.filter(id=reluserid).count(), 1)
content, response = self._deleteas("p1admin", self.testhelper.sub_p1.id, reluserid)
self.assertEquals(response.status_code, 204)
self.assertEquals(self.modelcls.objects.filter(id=reluserid).count(), 0)
def test_delete_superuser(self):
content, response = self._deleteas("superuser", self.testhelper.sub_p1.id, self.testreluser.id)
self.assertEquals(response.status_code, 204)
def test_delete_unauthorized(self):
content, response = self._deleteas("p2admin", self.testhelper.sub_p1.id, self.testreluser.id)
self.assertEquals(response.status_code, 403)
class TestRestInstancePeriodRest(TestCase):
def setUp(self):
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni:admin(uniadmin)',
subjects=['duck2000:admin(duck2000admin)'],
periods=['periodone:admin(oneadmin)',
'periodtwo',
'periodthree:admin(adminone)'])
self.client = RestClient()
def _geturl(self, periodid):
return '/devilry_subjectadmin/rest/period/{0}'.format(periodid)
def test_delete_denied(self):
self.client.login(username='******', password='******')
content, response = self.client.rest_delete(self._geturl(self.testhelper.duck2000_periodone.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_periodone.id))
self.assertEquals(response.status_code, 200)
self.assertEquals(content['id'], self.testhelper.duck2000_periodone.id)
self.assertEquals(Period.objects.filter(id=self.testhelper.duck2000_periodone.id).count(), 0)
def test_get(self):
period = self.testhelper.duck2000_periodone
for username in ('student1', 'student2', 'student3', 'student4'):
user = self.testhelper.create_user(username)
period.relatedstudent_set.create(user=user)
for username in ('examiner1', 'examiner2'):
user = self.testhelper.create_user(username)
period.relatedexaminer_set.create(user=user)
self.client.login(username='******', password='******')
content, response = self.client.rest_get(self._geturl(self.testhelper.duck2000_periodone.id))
self.assertEquals(response.status_code, 200)
self.assertEquals(content['id'], self.testhelper.duck2000_periodone.id)
self.assertEquals(content['short_name'], self.testhelper.duck2000_periodone.short_name)
self.assertEquals(content['long_name'], self.testhelper.duck2000_periodone.long_name)
self.assertEquals(content['parentnode'], self.testhelper.duck2000_periodone.parentnode_id)
self.assertEquals(content['can_delete'], self.testhelper.duck2000_periodone.can_delete(self.testhelper.uniadmin))
self.assertEquals(content['number_of_relatedexaminers'], 2)
self.assertEquals(content['number_of_relatedstudents'], 4)
self.assertEquals(set(content.keys()),
set(['short_name', 'long_name', 'admins', 'etag',
'can_delete', 'parentnode', 'id', 'inherited_admins',
'start_time', 'end_time', 'breadcrumb',
'number_of_relatedexaminers', 'number_of_relatedstudents']))
def test_get_admins(self):
self.client.login(username='******', password='******')
content, response = self.client.rest_get(self._geturl(self.testhelper.duck2000_periodone.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_periodone.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_periodadmin(self):
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['p1:admin(p1admin)'])
self.client.login(username='******', password='******')
content, response = self.client.rest_get(self._geturl(self.testhelper.sub_p1.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'}])
def test_get_breadcrumb_subjectadmin(self):
self.testhelper.add(nodes='uni',
subjects=['sub:admin(subadm)'],
periods=['p1'])
self.client.login(username='******', password='******')
content, response = self.client.rest_get(self._geturl(self.testhelper.sub_p1.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'}])
def test_get_breadcrumb_nodeadmin(self):
self.testhelper.add(nodes='uni:admin(uniadmin).inf',
subjects=['sub'],
periods=['p1'])
self.client.login(username='******', password='******')
content, response = self.client.rest_get(self._geturl(self.testhelper.sub_p1.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'}])
def test_get_breadcrumb_superuser(self):
self.testhelper.add(nodes='uni.inf',
subjects=['sub'],
periods=['p1'])
self.testhelper.create_superuser('super')
self.client.login(username='******', password='******')
content, response = self.client.rest_get(self._geturl(self.testhelper.sub_p1.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'}])
def test_get_can_not_delete(self):
self.client.login(username='******', password='******')
content, response = self.client.rest_get(self._geturl(self.testhelper.duck2000_periodone.id))
self.assertFalse(content['can_delete'])
def test_put(self):
self.client.login(username='******', password='******')
data = {'short_name': 'duck2000',
'long_name': 'Updated',
'admins': [],
'start_time': isoformat_relativetime(days=-2),
'end_time': isoformat_relativetime(days=2),
'parentnode': 1}
content, response = self.client.rest_put(self._geturl(self.testhelper.duck2000_periodone.id),
data=data)
self.assertEquals(response.status_code, 200)
self.assertEquals(content['id'], self.testhelper.duck2000_periodone.id)
self.assertEquals(content['short_name'], self.testhelper.duck2000.short_name)
self.assertEquals(content['long_name'], 'Updated')
self.assertEquals(content['parentnode'], 1)
self.assertEquals(set(content.keys()),
set(['short_name', 'long_name', 'admins', 'etag',
'can_delete', 'parentnode', 'id', 'inherited_admins',
'start_time', 'end_time', 'breadcrumb',
'number_of_relatedstudents', 'number_of_relatedexaminers']))
updated = Period.objects.get(id=self.testhelper.duck2000_periodone.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}],
'start_time': isoformat_relativetime(days=-2),
'end_time': isoformat_relativetime(days=2),
'parentnode': 1}
content, response = self.client.rest_put(self._geturl(self.testhelper.duck2000_periodone.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 = Period.objects.get(id=self.testhelper.duck2000_periodone.id)
self.assertEquals(updated.admins.all().count(), 3)
class TestGroupRest(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(len(content), 1)
first = content[0]
self.assertEquals(set(first.keys()),
set(['name', 'id', 'etag', 'status', 'is_open', 'parentnode',
'feedback', 'deadlines', 'candidates', 'tags',
'examiners', 'num_deliveries']))
self.assertEquals(first['name'], 'g1')
self.assertEquals(first['is_open'], False)
self.assertEquals(first['parentnode'], self.a1id)
self.assertEquals(first['num_deliveries'], 0)
self.assertEquals(first['feedback'], None)
self.assertEquals(first['deadlines'], [])
self.assertEquals(first['candidates'], [])
self.assertEquals(first['examiners'], [])
self.assertEquals(first['tags'], [])
groups = self.testhelper.sub_p1_a1.assignmentgroups.all()
self.assertEquals(len(groups), 1)
self.assertEquals(first['id'], groups[0].id)
def _test_create_as(self, username):
a1 = self.testhelper.sub_p1_a1
a1.first_deadline = datetime(2005, 1, 1)
a1.save()
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(len(content), 1)
first = content[0]
self.assertEquals(first['name'], 'g1')
self.assertEquals(first['is_open'], True) # NOTE: Overrides the parameter since first_deadline is set.
self.assertEquals(first['parentnode'], self.a1id)
self.assertEquals(first['num_deliveries'], 0)
# Feedback
self.assertEquals(first['feedback'], None)
# Deadlines
self.assertEquals(len(first['deadlines']), 1)
self.assertEquals(first['deadlines'][0]['deadline'], '2005-01-01T00:00:00')
self.assertEquals(set(first['deadlines'][0].keys()), set(['id', 'deadline']))
# Tags
self.assertEquals(len(first['tags']), 1)
tag = first['tags'][0]
self.assertEquals(tag['tag'], 'mytag')
self.assertEquals(set(tag.keys()), set(['id', 'tag']))
# Examiners
self.assertEquals(len(first['examiners']), 1)
examiner = first['examiners'][0]
self.assertEquals(set(examiner.keys()),
set(['id', 'user']))
self.assertEquals(set(examiner['user'].keys()),
set(['email', 'full_name', 'id', 'username', 'displayname']))
self.assertEquals(examiner['user']['id'], self.testhelper.examiner1.id)
self.assertEquals(examiner['user']['username'], 'examiner1')
# Candidates
self.assertEquals(len(first['candidates']), 1)
candidate = first['candidates'][0]
self.assertEquals(set(candidate.keys()),
set(['id', 'user', 'candidate_id']))
self.assertEquals(set(candidate['user'].keys()),
set(['email', 'full_name', 'id', 'username', 'displayname']))
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(first['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': None,
'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)
#
#
# PUT
#
#
def _putas(self, username, assignment_id, data={}):
self.client.login(username=username, password='******')
return self.client.rest_put(self._geturl(assignment_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 = [{'id': group.id,
'name': 'changed',
'is_open': False}]
content, response = self._putas('a1admin', self.a1id, data)
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 1)
first = content[0]
self.assertEquals(set(first.keys()),
set(['name', 'id', 'etag', 'status', 'is_open', 'parentnode',
'feedback', 'deadlines', 'candidates', 'tags',
'examiners', 'num_deliveries']))
self.assertEquals(first['name'], 'changed')
self.assertEquals(first['is_open'], False)
self.assertEquals(first['parentnode'], self.a1id)
self.assertEquals(first['num_deliveries'], 0)
self.assertEquals(first['feedback'], None)
self.assertEquals(first['deadlines'], [])
self.assertEquals(first['candidates'], [])
self.assertEquals(first['examiners'], [])
self.assertEquals(first['tags'], [])
groups = self.testhelper.sub_p1_a1.assignmentgroups.all()
self.assertEquals(len(groups), 1)
self.assertEquals(first['id'], groups[0].id)
def _test_put_as(self, username):
group = self._add_group('g1', candidates='candidate2', examiners='examiner2')
data = [{'id': group.id,
'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, data)
#from pprint import pprint
#print 'Response content:'
#pprint(content)
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content), 1)
first = content[0]
self.assertEquals(first['name'], 'changed')
self.assertEquals(first['is_open'], False)
self.assertEquals(first['parentnode'], self.a1id)
self.assertEquals(first['num_deliveries'], 0)
# Feedback
self.assertEquals(first['feedback'], None)
# Deadlines
self.assertEquals(first['deadlines'], [])
# Tags
self.assertEquals(len(first['tags']), 1)
tag = first['tags'][0]
self.assertEquals(tag['tag'], 'mytag')
self.assertEquals(set(tag.keys()), set(['id', 'tag']))
# Examiners
self.assertEquals(len(first['examiners']), 1)
examiner = first['examiners'][0]
self.assertEquals(set(examiner.keys()),
set(['id', 'user']))
self.assertEquals(set(examiner['user'].keys()),
set(['email', 'full_name', 'id', 'username', 'displayname']))
self.assertEquals(examiner['user']['id'], self.testhelper.examiner1.id)
self.assertEquals(examiner['user']['username'], 'examiner1')
# Candidates
self.assertEquals(len(first['candidates']), 1)
candidate = first['candidates'][0]
self.assertEquals(set(candidate.keys()),
set(['id', 'user', 'candidate_id']))
self.assertEquals(set(candidate['user'].keys()),
set(['email', 'full_name', 'id', 'username', 'displayname']))
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.testhelper.create_superuser('superuser')
self._test_put_as('superuser')
def test_put_as_assignmentadmin(self):
self._test_put_as('a1admin')
def test_put_doesnotexist(self):
data = [{'id': 100000,
'name': 'changed',
'is_open': False}]
content, response = self._putas('grandma', 10000, 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, 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 = [{'id': group.id,
'name': 'changed',
'is_open': False,
'feedback': 'should be ignored',
'num_deliveries': 'should be ignored',
'deadlines': 'should be ignored'}]
content, response = self._putas('a1admin', self.a1id, data)
self.assertEquals(response.status_code, 200)
#
#
# DELETE
#
#
def _add_group_with_delivery(self, name, **kwargs):
group = self._add_group(name, **kwargs)
self.testhelper.add_to_path('uni;sub.p1.a1.{0}.d1'.format(name))
self.testhelper.add_delivery(group)
return group
def _deleteas(self, username, assignment_id, data):
self.client.login(username=username, password='******')
return self.client.rest_put(self._geturl(assignment_id), data,
X_DEVILRY_DELETEHACK='1')
def _test_delete_ok_as(self, group, username):
data = [{'id': group.id}]
content, response = self._deleteas(username, self.a1id, data)
self.assertEquals(response.status_code, 204)
self.assertEquals(content, None)
self.assertFalse(AssignmentGroup.objects.filter(id=group.id).exists())
def test_delete_as_superuser(self):
self.testhelper.create_superuser('superuser')
group = self._add_group('g1', candidates='candidate2', examiners='examiner2')
self._test_delete_ok_as(group, 'superuser')
def test_delete_as_a1admin(self):
group = self._add_group('g1', candidates='candidate2', examiners='examiner2')
self._test_delete_ok_as(group, 'a1admin')
def _test_delete_noperm_as(self, group, username):
data = [{'id': group.id}]
content, response = self._deleteas(username, self.a1id, data)
#from pprint import pprint
#print 'Response content:'
#pprint(content)
self.assertEquals(response.status_code, 403)
self.assertTrue(AssignmentGroup.objects.filter(id=group.id).exists())
def test_delete_with_content_as_superuser(self):
self.testhelper.create_superuser('superuser')
group = self._add_group_with_delivery('g1',
candidates='candidate2',
examiners='examiner2')
self._test_delete_ok_as(group, 'superuser')
def test_delete_with_content_as_a1admin(self):
group = self._add_group_with_delivery('g1',
candidates='candidate2',
examiners='examiner2')
self._test_delete_noperm_as(group, 'a1admin')
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.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.uniadmin))
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']))
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']))
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(self):
self.testhelper.add(nodes='duck.mat.inf',
subjects=['s1'],
periods=['p1'],
assignments=['a1:admin(a1admin)'])
self.client.login(username='******', password='******')
content, response = self.client.rest_get(self._geturl(self.testhelper.s1_p1_a1.id))
self.assertEquals(response.status_code, 200)
th = self.testhelper
self.assertEquals(content['breadcrumb'],
[{u'id': th.duck.id, u'short_name': u'duck', u'type': u'Node'},
{u'id': th.duck_mat.id, u'short_name': u'mat', u'type': u'Node'},
{u'id': th.duck_mat_inf.id, u'short_name': u'inf', u'type': u'Node'},
{u'id': th.s1.id, u'short_name': u's1', u'type': u'Subject'},
{u'id': th.s1_p1.id, u'short_name': u'p1', u'type': u'Period'}])
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']))
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 TestInstanceRelatedUserMixin(object):
def setUp(self):
self.client = RestClient()
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni',
subjects=['sub'],
periods=['p1:admin(p1admin)', 'p2:admin(p2admin)'])
self.testhelper.create_superuser("superuser")
self.testreluser = self.create_reluser_on_p1('testuser', tags='group1,group2')
def create_reluser_on_p1(self, username, tags):
raise NotImplementedError()
def get_url(self, periodid, reluserid):
raise NotImplementedError()
def get_valid_putdata(self):
return {'period': self.testhelper.sub_p1.id,
'tags': 'group10,group20',
'user': self.testhelper.testuser.id}
def _getas(self, username, periodid, id, **data):
self.client.login(username=username, password='******')
return self.client.rest_get(self.get_url(periodid, id), **data)
def test_get_404(self):
content, response = self._getas('p1admin', self.testhelper.sub_p1.id, 40000000)
self.assertEquals(response.status_code, 404)
def test_get_unauthorized(self):
content, response = self._getas('p2admin', self.testhelper.sub_p1.id, self.testreluser.id)
self.assertEquals(response.status_code, 403)
def test_get_superuser(self):
content, response = self._getas('superuser', self.testhelper.sub_p1.id, self.testreluser.id)
self.assertEquals(response.status_code, 200)
def _putas(self, username, periodid, id, data):
self.client.login(username=username, password='******')
return self.client.rest_put(self.get_url(periodid, id), data)
def test_put_unauthorized(self):
content, response = self._putas('p2admin', self.testhelper.sub_p1.id,
self.testreluser.id, self.get_valid_putdata())
self.assertEquals(response.status_code, 403)
def test_put_superuser(self):
content, response = self._putas('superuser', self.testhelper.sub_p1.id,
self.testreluser.id, self.get_valid_putdata())
self.assertEquals(response.status_code, 200)
def test_put(self):
content, response = self._putas('p1admin', self.testhelper.sub_p1.id,
self.testreluser.id, self.get_valid_putdata())
self.assertEquals(response.status_code, 200)
self.assertEquals(content['period'], self.testhelper.sub_p1.id)
self.assertEquals(content['tags'], 'group10,group20')
self.assertEquals(set(content['user'].keys()),
set(['email', 'full_name', 'id', 'username', 'displayname']))
self.assertEquals(content['user']['id'], self.testreluser.user.id)
self.assertEquals(content['user']['username'], 'testuser')
return content
def _deleteas(self, username, periodid, id):
self.client.login(username=username, password='******')
return self.client.rest_delete(self.get_url(periodid, id))
def test_delete(self):
reluserid = self.testreluser.id
self.assertEquals(self.modelcls.objects.filter(id=reluserid).count(), 1)
content, response = self._deleteas('p1admin',
self.testhelper.sub_p1.id,
reluserid)
self.assertEquals(response.status_code, 204)
self.assertEquals(self.modelcls.objects.filter(id=reluserid).count(), 0)
def test_delete_superuser(self):
content, response = self._deleteas('superuser',
self.testhelper.sub_p1.id,
self.testreluser.id)
self.assertEquals(response.status_code, 204)
def test_delete_unauthorized(self):
content, response = self._deleteas('p2admin',
self.testhelper.sub_p1.id,
self.testreluser.id)
self.assertEquals(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["gradeeditor"],
{
u"gradeeditorid": u"approved",
u"title": u"Approved/not approved",
u"shortformat": {u"widget": u"bool", u"shorthelp": u"Must be one of: true, false."},
},
)
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",
"gradeeditor",
"number_of_groups_where_is_examiner",
]
),
)
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_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",
"gradeeditor",
"number_of_groups_where_is_examiner",
]
),
)
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 TestRestInstanceSubjectRest(TestCase):
def setUp(self):
self.testhelper = TestHelper()
self.testhelper.add(nodes="uni:admin(uniadmin)", subjects=["duck2000:admin(duck2000admin):ln(Something fancy)"])
self.client = RestClient()
def _geturl(self, subjectid):
return "/devilry_subjectadmin/rest/subject/{0}".format(subjectid)
def test_delete_denied(self):
self.client.login(username="******", password="******")
content, response = self.client.rest_delete(self._geturl(self.testhelper.duck2000.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.id))
self.assertEquals(response.status_code, 200)
self.assertEquals(content["id"], self.testhelper.duck2000.id)
self.assertEquals(Subject.objects.filter(id=self.testhelper.duck2000.id).count(), 0)
def test_delete_notempty(self):
self.testhelper.add_to_path("uni;duck2000.p1")
self.client.login(username="******", password="******")
content, response = self.client.rest_delete(self._geturl(self.testhelper.duck2000.id))
self.assertEquals(response.status_code, 403)
self.assertIn("Only superadmins can delete non-empty items", content["detail"])
def test_get(self):
self.client.login(username="******", password="******")
content, response = self.client.rest_get(self._geturl(self.testhelper.duck2000.id))
self.assertEquals(response.status_code, 200)
self.assertEquals(content["id"], self.testhelper.duck2000.id)
self.assertEquals(content["short_name"], self.testhelper.duck2000.short_name)
self.assertEquals(content["long_name"], self.testhelper.duck2000.long_name)
self.assertEquals(content["parentnode"], self.testhelper.duck2000.parentnode_id)
self.assertEquals(content["can_delete"], self.testhelper.duck2000.can_delete(self.testhelper.uniadmin))
self.assertEquals(
set(content.keys()),
set(
[
"short_name",
"long_name",
"admins",
"etag",
"can_delete",
"parentnode",
"id",
"inherited_admins",
"breadcrumb",
]
),
)
def test_get_admins(self):
self.client.login(username="******", password="******")
content, response = self.client.rest_get(self._geturl(self.testhelper.duck2000.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.id))
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content["inherited_admins"]), 1)
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.assertEquals(inherited_adminusernames, ["uniadmin"])
def test_get_breadcrumb_subjectadmin(self):
self.testhelper.add(nodes="uni.inf", subjects=["sub:admin(subadm)"])
self.client.login(username="******", password="******")
content, response = self.client.rest_get(self._geturl(self.testhelper.sub.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"}])
def test_get_breadcrumb_nodeadmin(self):
self.testhelper.add(nodes="uni:admin(uniadm).inf", subjects=["sub"])
self.client.login(username="******", password="******")
content, response = self.client.rest_get(self._geturl(self.testhelper.sub.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"},
],
)
def test_get_breadcrumb_superuser(self):
self.testhelper.add(nodes="uni.inf", subjects=["sub"])
self.testhelper.create_superuser("super")
self.client.login(username="******", password="******")
content, response = self.client.rest_get(self._geturl(self.testhelper.sub.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"},
],
)
def test_get_can_not_delete(self):
self.client.login(username="******", password="******")
content, response = self.client.rest_get(self._geturl(self.testhelper.duck2000.id))
self.assertFalse(content["can_delete"])
def test_put(self):
self.client.login(username="******", password="******")
data = {"short_name": "duck2000", "long_name": "Updated", "admins": [], "parentnode": 1}
content, response = self.client.rest_put(self._geturl(self.testhelper.duck2000.id), data=data)
self.assertEquals(response.status_code, 200)
self.assertEquals(content["id"], self.testhelper.duck2000.id)
self.assertEquals(content["short_name"], self.testhelper.duck2000.short_name)
self.assertEquals(content["long_name"], "Updated")
self.assertEquals(content["parentnode"], 1)
self.assertEquals(
set(content.keys()),
set(
[
"short_name",
"long_name",
"admins",
"etag",
"can_delete",
"parentnode",
"id",
"inherited_admins",
"breadcrumb",
]
),
)
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},
],
"parentnode": 1,
}
content, response = self.client.rest_put(self._geturl(self.testhelper.duck2000.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")
def test_put_generated_fields(self):
self.client.login(username="******", password="******")
data = {
"short_name": "duck2000",
"long_name": "Updated",
"admins": [],
"parentnode": 1,
"breadcrumb": [],
"can_delete": False,
"inherited_admins": [],
}
content, response = self.client.rest_put(self._geturl(self.testhelper.duck2000.id), data=data)
self.assertEquals(response.status_code, 200)
class TestRestInstanceSubjectRest(TestCase):
def setUp(self):
self.testhelper = TestHelper()
self.testhelper.add(nodes='uni:admin(uniadmin)',
subjects=['duck2000:admin(duck2000admin):ln(Something fancy)'])
self.client = RestClient()
def _geturl(self, subjectid):
return '/devilry_subjectadmin/rest/subject/{0}'.format(subjectid)
def test_delete_denied(self):
self.client.login(username='******', password='******')
content, response = self.client.rest_delete(self._geturl(self.testhelper.duck2000.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.id))
self.assertEquals(response.status_code, 200)
self.assertEquals(content['id'], self.testhelper.duck2000.id)
self.assertEquals(Subject.objects.filter(id=self.testhelper.duck2000.id).count(), 0)
def test_delete_notempty(self):
self.testhelper.add_to_path('uni;duck2000.p1')
self.client.login(username='******', password='******')
content, response = self.client.rest_delete(self._geturl(self.testhelper.duck2000.id))
self.assertEquals(response.status_code, 403)
self.assertIn('Only superadmins can delete non-empty items', content['detail'])
def test_get(self):
self.client.login(username='******', password='******')
content, response = self.client.rest_get(self._geturl(self.testhelper.duck2000.id))
self.assertEquals(response.status_code, 200)
self.assertEquals(content['id'], self.testhelper.duck2000.id)
self.assertEquals(content['short_name'], self.testhelper.duck2000.short_name)
self.assertEquals(content['long_name'], self.testhelper.duck2000.long_name)
self.assertEquals(content['parentnode'], self.testhelper.duck2000.parentnode_id)
self.assertEquals(content['can_delete'], self.testhelper.duck2000.can_delete(self.testhelper.uniadmin))
self.assertEquals(set(content.keys()),
set(['short_name', 'long_name', 'admins', 'etag',
'can_delete', 'parentnode', 'id', 'inherited_admins',
'breadcrumb']))
def test_get_admins(self):
self.client.login(username='******', password='******')
content, response = self.client.rest_get(self._geturl(self.testhelper.duck2000.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.id))
self.assertEquals(response.status_code, 200)
self.assertEquals(len(content['inherited_admins']), 1)
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.assertEquals(inherited_adminusernames, ['uniadmin'])
def test_get_breadcrumb_subjectadmin(self):
self.testhelper.add(nodes='uni.inf',
subjects=['sub:admin(subadm)'])
self.client.login(username='******', password='******')
content, response = self.client.rest_get(self._geturl(self.testhelper.sub.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'}])
def test_get_breadcrumb_nodeadmin(self):
self.testhelper.add(nodes='uni:admin(uniadm).inf',
subjects=['sub'])
self.client.login(username='******', password='******')
content, response = self.client.rest_get(self._geturl(self.testhelper.sub.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'}])
def test_get_can_not_delete(self):
self.client.login(username='******', password='******')
content, response = self.client.rest_get(self._geturl(self.testhelper.duck2000.id))
self.assertFalse(content['can_delete'])
def test_put(self):
self.client.login(username='******', password='******')
data = {'short_name': 'duck2000',
'long_name': 'Updated',
'admins': [],
'parentnode': 1}
content, response = self.client.rest_put(self._geturl(self.testhelper.duck2000.id),
data=data)
self.assertEquals(response.status_code, 200)
self.assertEquals(content['id'], self.testhelper.duck2000.id)
self.assertEquals(content['short_name'], self.testhelper.duck2000.short_name)
self.assertEquals(content['long_name'], 'Updated')
self.assertEquals(content['parentnode'], 1)
self.assertEquals(set(content.keys()),
set(['short_name', 'long_name', 'admins', 'etag',
'can_delete', 'parentnode', 'id', 'inherited_admins',
'breadcrumb']))
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}],
'parentnode': 1}
content, response = self.client.rest_put(self._geturl(self.testhelper.duck2000.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')
def test_put_generated_fields(self):
self.client.login(username='******', password='******')
data = {'short_name': 'duck2000',
'long_name': 'Updated',
'admins': [],
'parentnode': 1,
'breadcrumb': [],
'can_delete': False,
'inherited_admins': []}
content, response = self.client.rest_put(self._geturl(self.testhelper.duck2000.id),
data=data)
self.assertEquals(response.status_code, 200)
