class TestRestAssignmentListing(TestCase): def setUp(self): self.testhelper = TestHelper() #self.testhelper.add(nodes='uni:admin(uniadmin)', #subjects=['duck2000:admin(adminone,admintwo):ln(Something fancy)', #'duck3000', #'duck1000:admin(adminone)', #'duck4000:admin(adminone,admintwo,singleadmin)']) self.client = RestClient() def _get(self, **data): return self.client.rest_get(reverse('devilry_examiner-rest-assignmentlisting'), **data) def _getas(self, username, **data): self.client.login(username=username, password='******') return self._get(**data) def test_get(self): self.testhelper.create_user('examiner1') content, response = self._getas('examiner1') self.assertEquals(response.status_code, 200) self.assertEquals(content, ['Hello', 'world']) def test_get_noauth(self): content, response = self._get() self.assertEquals(response.status_code, 401)
class TestLanguageSelect(TestCase): def setUp(self): self.client = RestClient() self.url = '/devilry_i18n/rest/languageselect' self.testhelper = TestHelper() self.testhelper.create_user('testuser') def _getas(self, username): self.client.login(username=username, password='******') return self.client.rest_get(self.url) def _get_languagecode(self, username): user = User.objects.get(username=username) return user.devilryuserprofile.languagecode def _set_languagecode(self, username, languagecode): profile = User.objects.get(username=username).devilryuserprofile profile.languagecode = languagecode profile.save() def test_get_languagecode_none(self): self.assertEquals(self._get_languagecode('testuser'), None) content, response = self._getas('testuser') self.assertEquals(response.status_code, 200) self.assertEquals(content['preferred'], None) self.assertEquals(content['selected']['languagecode'], settings.LANGUAGE_CODE) def test_get_languagecode_set(self): self._set_languagecode('testuser', 'nb') content, response = self._getas('testuser') self.assertEquals(response.status_code, 200) self.assertEquals(content['preferred'], 'nb') self.assertEquals(content['selected']['languagecode'], 'nb') def _putas(self, username, data): self.client.login(username=username, password='******') return self.client.rest_put(self.url, data) def test_put(self): content, response = self._putas('testuser', {'preferred': 'nb'}) self.assertEquals(response.status_code, 200) self.assertEquals(content['preferred'], 'nb') self.assertEquals(self._get_languagecode('testuser'), 'nb') def test_put_invalid(self): content, response = self._putas('testuser', {'preferred': 'invalid-code'}) self.assertEquals(response.status_code, 400) self.assertEquals(content['field_errors']['preferred'], [u'Invalid languagecode: invalid-code']) def test_put_with_extradata(self): content, response = self._putas('testuser', {'preferred': 'nb', 'selected': {'ignored': 'data'}, 'available': ['ignored']}) self.assertEquals(response.status_code, 200) self.assertEquals(content['preferred'], 'nb') self.assertEquals(self._get_languagecode('testuser'), 'nb')
class TestRestAggregatedStudentInfo(TestCase): def setUp(self): self.testhelper = TestHelper() self.client = RestClient() self.testhelper.add(nodes='uni:admin(uniadmin)', subjects=['sub'], periods=['p1:begins(-1)'], assignments=['a1']) self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1,student2):examiner(examiner1).d1:ends(5)') self.group = self.testhelper.sub_p1_a1_g1 def _get(self, user_id): return self.client.rest_get(reverse('devilry_nodeadmin-aggregatedstudentinfo', kwargs={'user_id': user_id})) def _getas(self, username, id): self.client.login(username=username, password='******') return self._get(id) def test_get(self): content, response = self._getas('uniadmin', self.testhelper.student1.id) self.assertEquals(response.status_code, 200) user = {u'username': u'student1', u'displayname': u'student1', u'id': 2, u'full_name': None, u'email': u'*****@*****.**'} self.assertEquals(content['user'], user) grouped_by_hierarky = content['grouped_by_hierarky'][0] self.assertEquals(set(grouped_by_hierarky.keys()), set([u'long_name', u'id', u'short_name', u'periods'])) period = grouped_by_hierarky['periods'][0] self.assertEquals(set(period.keys()), set([u'short_name', u'assignments', u'is_relatedstudent', u'start_time', u'is_active', u'qualified_forexams', u'long_name', u'end_time', u'id'])) assignments = period['assignments'][0] self.assertEquals(set(period.keys()), set([u'short_name', u'assignments', u'is_relatedstudent', u'start_time', u'is_active', u'qualified_forexams', u'long_name', u'end_time', u'id'])) groups = assignments['groups'][0] self.assertEquals(set(groups.keys()), set([u'status', u'active_feedback', u'id'])) def test_get_noauth(self): content, response = self._get(self.testhelper.student1.id) self.assertEquals(response.status_code, 401)
class 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 TestRestRecentDeliveries(TestCase): def setUp(self): self.client = RestClient() self.testhelper = TestHelper() self.testhelper.add(nodes='uni', subjects=['sub'], periods=['p1:begins(-1)'], assignments=['a1']) self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1).d1') self.group = self.testhelper.sub_p1_a1_g1 self.url = '/devilry_student/rest/recent-deliveries/' def _getas(self, username): self.client.login(username=username, password='******') return self.client.rest_get(self.url) def test_nobody(self): fileinfo = {'ok.py': ['print ', 'meh']} self.testhelper.add_delivery('sub.p1.a1.g1', fileinfo) self.testhelper.create_user('nobody') content, response = self._getas('nobody') self.assertEquals(response.status_code, 200) self.assertEquals(content, []) def test_recent_deliveries_minimal(self): fileinfo = {'ok.py': ['print ', 'meh']} self.testhelper.add_delivery('sub.p1.a1.g1', fileinfo) content, response = self._getas('student1') self.assertEquals(response.status_code, 200) self.assertEquals(len(content), 1) self.assertEquals(set(content[0].keys()), set(['id', 'assignment', 'period', 'subject', 'time_of_delivery', 'group', 'number'])) assignment = self.group.parentnode period = self.group.parentnode.parentnode subject = self.group.parentnode.parentnode.parentnode self.assertEquals(content[0]['assignment'], {u'id': assignment.id, u'long_name': u'A1', u'short_name': u'a1'}) self.assertEquals(content[0]['period'], {u'id': period.id, u'long_name': u'P1', u'short_name': u'p1'}) self.assertEquals(content[0]['subject'], {u'id': subject.id, u'long_name': u'Sub', u'short_name': u'sub'}) def test_recent_deliveries_over10(self): fileinfo = {'ok.py': ['print ', 'meh']} for x in xrange(8): self.testhelper.add_delivery('sub.p1.a1.g1', fileinfo) content, response = self._getas('student1') self.assertEquals(response.status_code, 200) self.assertEquals(len(content), 6)
class TestRestFindGroups(TestCase): def setUp(self): self.client = RestClient() self.testhelper = TestHelper() self.testhelper.add(nodes='uni', subjects=['sub'], periods=['p0:begins(-10):ends(2)', 'p1:begins(-1)', 'p2:begins(5)'], assignments=['a1']) self.testhelper.create_user('testuser') self.url = '/devilry_student/rest/find-groups/' def _getas(self, username, **data): self.client.login(username=username, password='******') return self.client.rest_get(self.url, **data) def test_find_groups_empty(self): content, response = self._getas('testuser') self.assertEquals(response.status_code, 200) self.assertEquals(content, []) def test_find_groups(self): # Add to the past period (should show up) self.testhelper.add_to_path('uni;sub.p0.a1.gOld:candidate(student1).d1') # Add to the active period (show show up) self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1).d1') self.testhelper.add_to_path('uni;sub.p1.a1.g2:candidate(student1,student2).d1') # Add to the future period (should not show up) self.testhelper.add_to_path('uni;sub.p2.a1.gFut:candidate(student1).d1') content, response = self._getas('student1', query='sub') self.assertEquals(response.status_code, 200) self.assertEquals(len(content), 3) self.assertEquals(set(content[0].keys()), set(['id', 'name', 'assignment', 'period', 'subject'])) groupnames = set([group['name'] for group in content]) self.assertEquals(groupnames, set(['g1', 'g2', 'gOld'])) content, response = self._getas('student1', query='old') self.assertEquals(response.status_code, 200) self.assertEquals(len(content), 1) content, response = self._getas('student1', query='p1 g2') self.assertEquals(response.status_code, 200) self.assertEquals(len(content), 1) self.assertEquals(content[0]['name'], 'g2')
class TestRestRecentFeedbacks(TestCase): def setUp(self): self.client = RestClient() self.testhelper = TestHelper() self.testhelper.add(nodes='uni', subjects=['sub'], periods=['p1:begins(-1)'], assignments=['a1']) self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1):examiner(examiner1).d1') self.group = self.testhelper.sub_p1_a1_g1 self.url = '/devilry_student/rest/recent-feedbacks/' def _getas(self, username): self.client.login(username=username, password='******') return self.client.rest_get(self.url) def test_nobody(self): fileinfo = {'ok.py': ['print ', 'meh']} self.testhelper.add_delivery('sub.p1.a1.g1', fileinfo) self.testhelper.create_user('nobody') content, response = self._getas('nobody') self.assertEquals(response.status_code, 200) self.assertEquals(content, []) def test_recent_feedbacks_minimal(self): fileinfo = {'ok.py': ['print ', 'meh']} delivery = self.testhelper.add_delivery('sub.p1.a1.g1', fileinfo) self.testhelper.add_feedback(delivery, verdict={'grade': 'F', 'points': 30, 'is_passing_grade': False}) content, response = self._getas('student1') self.assertEquals(response.status_code, 200) self.assertEquals(len(content), 1) self.assertEquals(set(content[0].keys()), set(['id', 'assignment', 'period', 'subject', 'number', 'last_feedback', 'group'])) def test_recent_deliveries_overflow(self): fileinfo = {'ok.py': ['print ', 'meh']} for x in xrange(8): delivery = self.testhelper.add_delivery('sub.p1.a1.g1', fileinfo) self.testhelper.add_feedback(delivery, verdict={'grade': '{0}/100'.format(x), 'points': x, 'is_passing_grade': False}) content, response = self._getas('student1') self.assertEquals(response.status_code, 200) self.assertEquals(len(content), 6)
class TestRestPreview(TestCase): def setUp(self): self.testhelper = TestHelper() self.testhelper.add(nodes='uni:admin(uniadmin)', subjects=['sub'], periods=['p1:admin(periodadmin):begins(-3):ends(6)']) self.client = RestClient() self.testhelper.create_superuser('superuser') def _get_url(self, periodid): return reverse('devilry_qualifiesforexam-rest-preview', kwargs={'id': periodid}) def _getas(self, username, periodid, previewdata, pluginsessionid='tst'): self.client.login(username=username, password='******') session = self.client.session session['qualifiesforexam-{0}'.format(pluginsessionid)] = previewdata session.save() return self.client.rest_get(self._get_url(periodid), pluginsessionid=pluginsessionid) def _test_getas(self, username): content, response = self._getas(username, self.testhelper.sub_p1.id, PreviewData(passing_relatedstudentids=[1, 2, 4])) self.assertEqual(response.status_code, 200) self.assertEqual(set(content.keys()), set(['pluginoutput', 'perioddata'])) self.assertEqual(content['pluginoutput'], {u'passing_relatedstudentids': [1, 2, 4]}) def test_get_as_periodadmin(self): self._test_getas('periodadmin') def test_get_as_nodeadmin(self): self._test_getas('uniadmin') def test_get_as_superuser(self): self._test_getas('superuser') def test_getas_nobody(self): self.testhelper.create_user('nobody') content, response = self._getas('nobody', self.testhelper.sub_p1.id, PreviewData(passing_relatedstudentids=[])) self.assertEqual(response.status_code, 403) def test_get_invalid_period(self): periodid = 10000 self.assertFalse(Period.objects.filter(id=periodid).exists()) # Just to be sure we dont get false positives content, response = self._getas('periodadmin', periodid, PreviewData(passing_relatedstudentids=[])) self.assertEqual(response.status_code, 403)
class TestRestAggregatedGroupInfo(TestCase): def setUp(self): self.client = RestClient() self.testhelper = TestHelper() self.testhelper.add(nodes='uni', subjects=['sub'], periods=['p1:begins(-1)'], assignments=['a1:admin(a1admin)']) self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1,student2):examiner(examiner1).d1:ends(5)') self.testhelper.add_to_path('uni;sub.p1.a1.g1.d2:ends(10)') self.group = self.testhelper.sub_p1_a1_g1 self.url = '/devilry_subjectadmin/rest/aggregated-groupinfo/{0}'.format(self.group.id) def _getas(self, username): self.client.login(username=username, password='******') return self.client.rest_get(self.url) def test_nobody(self): self.testhelper.create_user('nobody') content, response = self._getas('nobody') self.assertEquals(response.status_code, 403) def test_groupinfo(self): content, response = self._getas('a1admin') self.assertEquals(response.status_code, 200) self.assertEquals(set(content.keys()), set(['id', 'deadlines'])) self.assertEquals(content['id'], self.group.id) def test_groupinfo_superuser(self): self.testhelper.create_superuser('superuser') content, response = self._getas('superuser') self.assertEquals(response.status_code, 200) self.assertEquals(set(content.keys()), set(['id', 'deadlines'])) self.assertEquals(content['id'], self.group.id) def test_deadlines(self): content, response = self._getas('a1admin') deadlines = content['deadlines'] self.assertEquals(len(deadlines), 2) self.assertEquals(set(deadlines[0].keys()), set(['id', 'deadline', 'deliveries', 'text', 'offset_from_now', 'in_the_future']))
class TestRestDetailedPeriodOverview(TestCase): def setUp(self): self.testhelper = TestHelper() self.testhelper.add(nodes='uni:admin(uniadmin)', subjects=['sub'], periods=['p1:admin(periodadmin):begins(-3):ends(6)']) self.client = RestClient() self.testhelper.create_superuser('superuser') def _get_url(self, periodid): return reverse('devilry-subjectadmin-rest-detailedperiodoverview', kwargs={'id': periodid}) def _getas(self, username, periodid): self.client.login(username=username, password='******') return self.client.rest_get(self._get_url(periodid)) def _test_get_as(self, username): content, response = self._getas(username, self.testhelper.sub_p1.id) self.assertEqual(response.status_code, 200) # NOTE: This is tested in more detail in the API that generates the data (devilry.utils.groups_groupedby_relatedstudent_and_assignment) self.assertEqual(set(content.keys()), set([u'students_with_feedback_that_is_candidate_but_not_in_related', u'students_with_no_feedback_that_is_candidate_but_not_in_related', u'relatedstudents', u'assignments'])) def test_getlist_as_periodadmin(self): self._test_get_as('periodadmin') def test_getlist_as_nodeadmin(self): self._test_get_as('uniadmin') def test_getlist_as_superuser(self): self._test_get_as('superuser') def test_get_as_nobody(self): self.testhelper.create_user('nobody') content, response = self._getas('nobody', self.testhelper.sub_p1.id) self.assertEqual(response.status_code, 403) def test_get_invalid_id(self): content, response = self._getas('periodadmin', 10000) self.assertEqual(response.status_code, 403)
class TestRestSearchStudentContent(TestCase, AssertSearchResultMixin): def setUp(self): self.testhelper = TestHelper() self.testhelper.add(nodes='uni:ln(Test Uni)', subjects=['sub:ln(Test Sub)'], periods=['p1:begins(-2):ln(Test P1)'], assignments=['a1:ln(Test A1)'], assignmentgroups=[ 'TestGroup1:candidate(student1)', 'TestGroup2:candidate(student2,student1)', 'TestGroup3:candidate(student2)', 'TestGroup4:candidate(student3):examiner(student1)' ] ) self.client = RestClient() self.url = reverse('devilry_search_studentcontent') def _getas(self, username, **data): self.client.login(username=username, password='******') return self.client.rest_get(self.url, **data) def test_perms_student(self): with HaystackTestSettings(): content, response = self._getas('student1', search='Test') matches = content['matches'] self.assertEqual(len(matches), 2) self.assert_has_search_result(matches, type='core_assignmentgroup', title='Test A1', name='TestGroup1') self.assert_has_search_result(matches, type='core_assignmentgroup', title='Test A1', name='TestGroup2') def test_perms_student_unpublished(self): self.testhelper.sub_p1_a1.publishing_time = datetime.now() + timedelta(days=1) self.testhelper.sub_p1_a1.save() with HaystackTestSettings(): content, response = self._getas('student1', search='Test') matches = content['matches'] self.assertEqual(len(matches), 0)
class TestRestExaminerStats(TestCase): def setUp(self): self.testhelper = TestHelper() self.testhelper.add(nodes='uni:admin(uniadmin)', subjects=['sub'], periods=['p1:begins(-3):ends(6)'], assignments=['a1:admin(assignmentadmin)'] ) self.client = RestClient() self.testhelper.create_superuser('superuser') def _get_url(self, assignmentid): return reverse('devilry-subjectadmin-rest-examinerstats', kwargs={'id': assignmentid}) def _getas(self, username, periodid): self.client.login(username=username, password='******') return self.client.rest_get(self._get_url(periodid)) def _test_get_as(self, username): content, response = self._getas(username, self.testhelper.sub_p1_a1.id) self.assertEqual(response.status_code, 200) def test_perms_as_assignmentadmin(self): self._test_get_as('assignmentadmin') def test_perms_as_nodeadmin(self): self._test_get_as('uniadmin') def test_perms_as_superuser(self): self._test_get_as('superuser') def test_perms_as_nobody(self): self.testhelper.create_user('nobody') content, response = self._getas('nobody', self.testhelper.sub_p1_a1.id) self.assertEqual(response.status_code, 403) def test_perms_invalid_id(self): content, response = self._getas('assignmentadmin', 10000) self.assertEqual(response.status_code, 403)
class 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 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 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 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 TestListGroupRest(TestCase): def setUp(self): self.testhelper = TestHelper() self.client = RestClient() def _geturl(self, assignment_id): assignment_id = assignment_id or self.testhelper.sub_p1_a1.id return '/devilry_subjectadmin/rest/group/{0}/'.format(assignment_id) def _getas(self, username, assignment_id, **data): self.client.login(username=username, password='******') return self.client.rest_get(self._geturl(assignment_id), **data) def _create_testassignments(self): self.testhelper.add(nodes='uni', subjects=['duck1010'], periods=['firstsem'], assignments=['a1:admin(a1admin)', 'a2']) def _create_testdata(self): self._create_testassignments() for num in xrange(3): path = 'uni;duck1010.firstsem.a1.g{num}:candidate(student{num},extrastudent):examiner(examiner1,extraexaminer).d1' self.testhelper.add_to_path(path.format(**vars())) group = getattr(self.testhelper, 'duck1010_firstsem_a1_g{0}'.format(num)) group.tags.create(tag="stuff") group.tags.create(tag="lownumber") delivery = self.testhelper.add_delivery(group) if num != 2: self.testhelper.add_feedback(delivery, verdict=dict(grade='A', points=100, is_passing_grade=True)) def test_list_permissiondenied(self): self.testhelper.create_user('nobody') self._create_testassignments() a1 = self.testhelper.duck1010_firstsem_a1 content, response = self._getas('nobody', a1.id) self.assertEquals(response.status_code, 403) def _test_list_as(self, username): self._create_testdata() a1 = self.testhelper.duck1010_firstsem_a1 content, response = self._getas(username, a1.id) #from pprint import pprint #pprint(content) self.assertEquals(len(content), 3) self.assertEquals(set(content[0].keys()), set(['name', 'feedback', 'deadlines', 'id', 'etag', 'is_open', 'parentnode', 'candidates', 'tags', 'examiners', 'num_deliveries'])) # Properties directly from group self.assertEquals(AssignmentGroup.objects.get(id=content[0]['id']).parentnode_id, a1.id) self.assertEquals(content[0]['is_open'], False) self.assertEquals(content[0]['name'], 'g0') self.assertEquals(content[0]['num_deliveries'], 1) self.assertEquals(content[0]['parentnode'], a1.id) # Feedback feedback = content[0]['feedback'] self.assertEquals(set(feedback.keys()), set(['id', 'grade', 'is_passing_grade', 'points', 'save_timestamp'])) self.assertEquals(feedback['grade'], 'A') self.assertEquals(feedback['is_passing_grade'], True) self.assertEquals(feedback['points'], 100) # NULL feedback self.assertEquals(content[2]['feedback'], None) # Canididates def get_usernames(users): return [user['user']['username'] for user in users] self.assertEquals(len(content[0]['candidates']), 2) self.assertEquals(set(get_usernames(content[0]['candidates'])), set(['student0', 'extrastudent'])) self.assertEquals(set(content[0]['candidates'][0].keys()), set(['id', 'candidate_id', 'user'])) self.assertEquals(set(content[0]['candidates'][0]['user'].keys()), set(['email', 'full_name', 'id', 'username'])) # Examiners self.assertEquals(len(content[0]['examiners']), 2) self.assertEquals(set(get_usernames(content[0]['examiners'])), set(['examiner1', 'extraexaminer'])) self.assertEquals(set(content[0]['examiners'][0].keys()), set(['id', 'user'])) self.assertEquals(set(content[0]['examiners'][0]['user'].keys()), set(['email', 'full_name', 'id', 'username'])) # Deadlines self.assertEquals(len(content[0]['deadlines']), 1) deadline = content[0]['deadlines'][0] self.assertEquals(set(deadline.keys()), set(['id', 'deadline'])) # Tags self.assertEquals(len(content[0]['tags']), 2) tag = content[0]['tags'][0] self.assertEquals(set(tag.keys()), set(['id', 'tag'])) def test_list(self): self._test_list_as('a1admin') def test_list_as_superuser(self): self.testhelper.create_superuser('superuser') self._test_list_as('superuser')
class TestListRelatedUserOnAssignmentMixin(object): def setUp(self): self.client = RestClient() self.testhelper = TestHelper() self.testhelper.add(nodes='uni', subjects=['sub'], periods=['p1'], assignments=['a1:admin(a1admin)', 'a2:admin(a2admin)']) self.testhelper.add_to_path('uni;sub.p2') self.testhelper.create_superuser("superuser") self.testhelper.create_user('testuser') def get_url(self): """ Get url of rest API. """ raise NotImplementedError() def _listas(self, username, **data): self.client.login(username=username, password='******') return self.client.rest_get(self.get_url(), **data) def _create_user(self, index): username = "******".format(index) user = self.testhelper.create_user(username) user.email = username + '@example.com' user.devilryuserprofile.full_name = 'User {0}'.format(index) user.save() user.devilryuserprofile.save() return user def create_relateduser(self, period, index, tags=''): """ Create a related user of the type that we are testing. """ raise NotImplementedError() def _create_relatedusers(self, count): for index in xrange(count): self.create_relateduser(self.testhelper.sub_p1, index) def test_list(self): self._create_relatedusers(2) self.create_relateduser(self.testhelper.sub_p1, index=5, tags='group1,group2') self.create_relateduser(self.testhelper.sub_p2, index=20, tags='') # Not on p1, so we shold not get this in the listing! content, response = self._listas(self.testhelper.a1admin, period=self.testhelper.sub_p1.id) self.assertEquals(response.status_code, 200) self.assertEquals(len(content), 3) # Since this is 3, we did not get the user registered on p2. first, second, last = content self.assertEquals(first['user']['username'], 'reluser0') self.assertEquals(first['user']['full_name'] , 'User 0') self.assertEquals(first['tags'], '') self.assertEquals(second['tags'], '') self.assertEquals(second['user']['username'], 'reluser1') self.assertEquals(last['user']['username'], 'reluser5') self.assertEquals(last['tags'], 'group1,group2') return content def test_list_none(self): content, response = self._listas(self.testhelper.a1admin, period=self.testhelper.sub_p1.id) self.assertEquals(response.status_code, 200) self.assertEquals(len(content), 0) def test_list_superuser(self): self._create_relatedusers(2) content, response = self._listas(self.testhelper.superuser, period=self.testhelper.sub_p1.id) self.assertEquals(response.status_code, 200) self.assertEquals(len(content), 2) def test_list_not_admin(self): self._create_relatedusers(2) content, response = self._listas(self.testhelper.a2admin, period=self.testhelper.sub_p1.id) self.assertEquals(response.status_code, 403)
class 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 TestRestDeadlinesBulkList(TestCase): def setUp(self): self.testhelper = TestHelper() self.testhelper.add(nodes='uni', subjects=['sub'], periods=['p1:begins(-2)'], # 2 months ago assignments=['a1:admin(adm):pub(0)']) # 0 days after period begins self.client = RestClient() self.url = '/devilry_subjectadmin/rest/deadlinesbulk/{0}/'.format(self.testhelper.sub_p1_a1.id) def _listas(self, username, **data): self.client.login(username=username, password='******') return self.client.rest_get(self.url, **data) def test_get_empty(self): content, response = self._listas('adm') self.assertEquals(response.status_code, 200) self.assertEquals(len(content), 0) def test_get_simple(self): for groupnum in xrange(3): # deadline 5 days after assignment starts self.testhelper.add_to_path('uni;sub.p1.a1.g{0}.d1:ends(5)'.format(groupnum)) content, response = self._listas('adm') self.assertEquals(response.status_code, 200) self.assertEquals(len(content), 1) d1 = content[0] self.assertEquals(set(d1.keys()), set(['deadline', 'text', 'groups', 'offset_from_now', 'in_the_future', 'bulkdeadline_id', 'url', 'groups'])) self.assertEquals(len(d1['groups']), 3) self.assertEquals(d1['in_the_future'], False) self.assertEquals(d1['text'], None) def test_get_textdifference(self): for groupnum in xrange(3): # deadline 5 days after assignment starts self.testhelper.add_to_path('uni;sub.p1.a1.g{0}.d1:ends(5)'.format(groupnum)) # Change text on g1_d1, which should make it a separate entry in the list self.testhelper.sub_p1_a1_g1_d1.text = 'Test' self.testhelper.sub_p1_a1_g1_d1.save() content, response = self._listas('adm') self.assertEquals(response.status_code, 200) self.assertEquals(len(content), 2) g2_g3_d1 = content[0] g1_d1 = content[1] self.assertEquals(g1_d1['text'], 'Test') self.assertEquals(len(g1_d1['groups']), 1) self.assertEquals(g2_g3_d1['text'], None) self.assertEquals(len(g2_g3_d1['groups']), 2) def test_get_multiple_and_order(self): for groupnum in xrange(3): # deadline 5 days after assignment starts self.testhelper.add_to_path('uni;sub.p1.a1.g{0}.d1:ends(5)'.format(groupnum)) for groupnum in xrange(2): # deadline 70 days after assignment starts, which should be in the future self.testhelper.add_to_path('uni;sub.p1.a1.g{0}.d2:ends(70)'.format(groupnum)) content, response = self._listas('adm') self.assertEquals(response.status_code, 200) self.assertEquals(len(content), 2) d1 = content[1] d2 = content[0] self.assertEquals(len(d1['groups']), 3) self.assertEquals(d1['in_the_future'], False) self.assertEquals(len(d2['groups']), 2) self.assertEquals(d2['in_the_future'], True) def test_get_nobody(self): self.testhelper.create_user('nobody') content, response = self._listas('nobody') self.assertEquals(response.status_code, 403)
class TestRestListOrCreatePeriodRest(TestCase): def setUp(self): self.testhelper = TestHelper() self.testhelper.add(nodes='uni:admin(uniadmin)', subjects=['duck2000:admin(subadmin)'], periods=['one:admin(adminone)', 'two', 'three:admin(adminone)']) self.client = RestClient() self.url = '/devilry_subjectadmin/rest/period/' 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('adminone') self.assertEquals(response.status_code, 200) self.assertEquals(len(content), 2) self.assertEquals(set(content[0].keys()), set(['id', 'parentnode', 'etag', 'short_name', 'long_name', 'start_time', 'end_time', 'url'])) 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:admin(uniadmin)', subjects=['duck9000'], periods=['p1', 'p2']) content, response = self._listas('uniadmin', parentnode=self.testhelper.duck9000.id) self.assertEquals(response.status_code, 200) self.assertEquals(len(content), 2) shortnames = set([p['short_name'] for p in content]) self.assertEquals(shortnames, set(['p1', 'p2'])) 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('subadmin', {'short_name': 'test', 'long_name': 'Test', 'admins': [], 'start_time': isoformat_relativetime(days=-2), 'end_time': isoformat_relativetime(days=2), 'parentnode': self.testhelper.duck2000.id}) self.assertEquals(response.status_code, 201) self.assertEquals(content['long_name'], 'Test') self.assertEquals(content['short_name'], 'test') self.assertEquals(content['parentnode'], self.testhelper.duck2000.id) created = Period.objects.get(id=content['id']) self.assertEquals(created.short_name, 'test') self.assertEquals(created.long_name, 'Test') self.assertEquals(created.parentnode.id, self.testhelper.duck2000.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': [], 'start_time': isoformat_relativetime(days=-2), 'end_time': isoformat_relativetime(days=2), 'parentnode': self.testhelper.duck2000.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}], 'start_time': isoformat_relativetime(days=-2), 'end_time': isoformat_relativetime(days=2), 'parentnode': self.testhelper.duck2000.id}) self.assertEquals(response.status_code, 201) created = Period.objects.get(id=content['id']) admins = created.admins.all() self.assertEquals(len(admins), 1) self.assertEquals(admins[0].username, 'testadmin')
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 TestListOrCreateRelatedUserMixin(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.testhelper.create_user("testuser") def get_url(self): """ Get url of rest API. """ raise NotImplementedError() def _listas(self, username, **data): self.client.login(username=username, password="******") return self.client.rest_get(self.get_url(), **data) def _create_user(self, index): username = "******".format(index) user = self.testhelper.create_user(username) user.email = username + "@example.com" user.devilryuserprofile.full_name = "User {0}".format(index) user.save() user.devilryuserprofile.save() return user def create_relateduser(self, period, index, tags=""): """ Create a related user of the type that we are testing. """ raise NotImplementedError() def _create_relatedusers(self, count): for index in xrange(count): self.create_relateduser(self.testhelper.sub_p1, index) def test_list(self): self._create_relatedusers(2) self.create_relateduser(self.testhelper.sub_p1, index=5, tags="group1,group2") self.create_relateduser( self.testhelper.sub_p2, index=20, tags="" ) # Not on p1, so we shold not get this in the listing! content, response = self._listas("p1admin") self.assertEquals(response.status_code, 200) self.assertEquals(len(content), 3) # Since this is 3, we did not get the user registered on p2. first, second, last = content self.assertEquals(first["user"]["username"], "reluser0") self.assertEquals(first["user"]["full_name"], "User 0") self.assertEquals(first["tags"], "") self.assertEquals(second["tags"], "") self.assertEquals(second["user"]["username"], "reluser1") self.assertEquals(last["user"]["username"], "reluser5") self.assertEquals(last["tags"], "group1,group2") return content def test_list_none(self): content, response = self._listas("p1admin") self.assertEquals(response.status_code, 200) self.assertEquals(len(content), 0) def test_list_superuser(self): self._create_relatedusers(2) content, response = self._listas("superuser") self.assertEquals(response.status_code, 200) self.assertEquals(len(content), 2) def test_list_not_admin(self): self._create_relatedusers(2) content, response = self._listas("p2admin") self.assertEquals(response.status_code, 403) def _listqueryas(self, username, query): self.client.login(username=username, password="******") return self.client.rest_get(self.get_url(), **{"query": query}) def test_list_query(self): self._create_relatedusers(2) self.create_relateduser(self.testhelper.sub_p1, index=5, tags="group1,group2") self.create_relateduser( self.testhelper.sub_p2, index=20, tags="" ) # Not on p1, so we shold not get this in the listing! self.testhelper.reluser0.devilryuserprofile.full_name = "Superhero" self.testhelper.reluser0.devilryuserprofile.save() self.testhelper.reluser1.devilryuserprofile.full_name = "Super Not hero" self.testhelper.reluser1.email = "*****@*****.**" self.testhelper.reluser1.devilryuserprofile.save() self.testhelper.reluser1.save() content, response = self._listqueryas("p1admin", query="5") self.assertEquals(response.status_code, 200) self.assertEquals(len(content), 1) content, response = self._listqueryas("p1admin", query="HeRo") self.assertEquals(response.status_code, 200) self.assertEquals(len(content), 2) content, response = self._listqueryas("p1admin", query="group2") self.assertEquals(len(content), 1) content, response = self._listqueryas("p1admin", query="nothero@exAM") self.assertEquals(len(content), 1) def _createas(self, username, data): self.client.login(username=username, password="******") return self.client.rest_post(self.get_url(), data) def get_valid_createdata(self): """ Overridden in TestListOrCreateRelatedStudentRest. """ return { "period": self.testhelper.sub_p1.id, "user": self.testhelper.testuser.id, # TODO: Support username "tags": "tag1,tag2", } def _create_test_helper(self, username): self.assertEquals(self.modelcls.objects.all().count(), 0) content, response = self._createas(username, self.get_valid_createdata()) self.assertEquals(response.status_code, 201) self.assertEquals(content["user"].keys(), [u"username", u"email", u"full_name", u"id"]) self.assertEquals(content["user"]["username"], "testuser") self.assertEquals(content["user"]["id"], self.testhelper.testuser.id) self.assertEquals(content["tags"], "tag1,tag2") self.assertEquals(content["period"], self.testhelper.sub_p1.id) self.assertEquals(self.modelcls.objects.all().count(), 1) created = self.modelcls.objects.all()[0] self.assertEquals(created.user.username, "testuser") return content, created def test_create(self): return self._create_test_helper("p1admin") def test_create_not_admin(self): content, response = self._createas("p2admin", self.get_valid_createdata()) self.assertEquals(response.status_code, 403) def test_create_superuser(self): content, response = self._create_test_helper("superuser")
class TestRestAggregatedGroupInfo(TestCase): def setUp(self): self.client = RestClient() self.testhelper = TestHelper() self.testhelper.add(nodes='uni', subjects=['sub'], periods=['p1:begins(-1)'], assignments=['a1']) self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1,student2):examiner(examiner1).d1:ends(5)') self.testhelper.add_to_path('uni;sub.p1.a1.g1.d2:ends(10)') self.group = self.testhelper.sub_p1_a1_g1 self.url = '/devilry_student/rest/aggregated-groupinfo/{0}'.format(self.group.id) def _getas(self, username): self.client.login(username=username, password='******') return self.client.rest_get(self.url) def test_nobody(self): self.testhelper.create_user('nobody') content, response = self._getas('nobody') self.assertEquals(response.status_code, 403) def test_groupinfo(self): content, response = self._getas('student1') self.assertEquals(response.status_code, 200) self.assertEquals(set(content.keys()), set(['id', 'name', 'is_open', 'candidates', 'examiners', 'deadlines', 'active_feedback', 'deadline_handling', 'breadcrumbs'])) self.assertEquals(content['id'], self.group.id) self.assertEquals(content['name'], 'g1') self.assertEquals(content['is_open'], True) self.assertEquals(content['deadline_handling'], 0) self.assertEquals(content['active_feedback'], None) def test_candidates(self): content, response = self._getas('student1') candidates = content['candidates'] self.assertEquals(len(candidates), 2) self.assertEquals(set(candidates[0].keys()), set(['id', 'candidate_id', 'identifier', 'user'])) self.assertEquals(set(candidates[0]['user'].keys()), set(['id', 'username', 'email', 'full_name', 'displayname'])) def test_examiners(self): content, response = self._getas('student1') examiners = content['examiners'] self.assertEquals(len(examiners), 1) self.assertEquals(set(examiners[0].keys()), set(['id', 'user'])) self.assertEquals(set(examiners[0]['user'].keys()), set(['id', 'username', 'email', 'full_name', 'displayname'])) self.assertEquals(examiners[0]['user']['username'], 'examiner1') def test_examiners_anonymous(self): self.group.parentnode.anonymous = True self.group.parentnode.save() content, response = self._getas('student1') examiners = content['examiners'] self.assertEquals(examiners, None) def test_deadlines(self): content, response = self._getas('student1') deadlines = content['deadlines'] self.assertEquals(len(deadlines), 2) self.assertEquals(set(deadlines[0].keys()), set(['id', 'deadline', 'deliveries', 'text', 'offset_from_now', 'in_the_future'])) def test_breadcrumbs(self): content, response = self._getas('student1') breadcrumbs = content['breadcrumbs'] self.assertEquals(breadcrumbs, {u'assignment': {u'id': self.group.parentnode.id, u'long_name': u'A1', u'short_name': u'a1'}, u'period': {u'id': self.group.parentnode.parentnode.id, u'long_name': u'P1', u'short_name': u'p1'}, u'subject': {u'id': self.group.parentnode.parentnode.parentnode.id, u'long_name': u'Sub', u'short_name': u'sub'}})
class TestRestOpenGroups(TestCase): def setUp(self): self.client = RestClient() self.testhelper = TestHelper() self.testhelper.add(nodes='uni', subjects=['sub'], periods=['p0:begins(-10):ends(2)', 'p1:begins(-2):ends(6)', 'p2:begins(5)'], assignments=['a1']) self.testhelper.create_user('testuser') self.url = '/devilry_student/rest/open-groups/' def _getas(self, username, **data): self.client.login(username=username, password='******') return self.client.rest_get(self.url, **data) def test_open_groups_empty(self): content, response = self._getas('testuser') self.assertEquals(response.status_code, 200) self.assertEquals(content, []) def test_open_groups(self): # Add 3 to the active period, but close one of the groups self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1).d1') self.testhelper.add_to_path('uni;sub.p1.a1.g2:candidate(student1).d1') self.testhelper.add_to_path('uni;sub.p1.a1.g3:candidate(student1).d1') self.testhelper.sub_p1_a1_g1.is_open = False self.testhelper.sub_p1_a1_g1.save() # Add to the past and the future periods (should not show up) self.testhelper.add_to_path('uni;sub.p0.a1.gX:candidate(student1).d1') self.testhelper.add_to_path('uni;sub.p2.a1.gY:candidate(student1).d1') content, response = self._getas('student1') self.assertEquals(response.status_code, 200) self.assertEquals(len(content), 2) groupnames = set([group['name'] for group in content]) self.assertEquals(groupnames, set(['g2', 'g3'])) def test_deadline_expired_and_order(self): self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1).d1:ends(1)') self.testhelper.add_to_path('uni;sub.p1.a1.g2:candidate(student1).d1:ends(70)') content, response = self._getas('student1') self.assertEquals(response.status_code, 200) self.assertEquals(len(content), 2) self.assertEquals(content[0]['name'], 'g1') self.assertEquals(content[0]['active_deadline']['deadline_expired'], True) self.assertEquals(content[1]['name'], 'g2') self.assertEquals(content[1]['active_deadline']['deadline_expired'], False) def test_only_deadline_expired(self): self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1).d1:ends(1)') self.testhelper.add_to_path('uni;sub.p1.a1.g2:candidate(student1).d1:ends(70)') content, response = self._getas('student1', only='deadline_expired') self.assertEquals(response.status_code, 200) self.assertEquals(len(content), 1) self.assertEquals(content[0]['name'], 'g1') self.assertEquals(content[0]['active_deadline']['deadline_expired'], True) def test_only_deadline_not_expired(self): self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1).d1:ends(1)') self.testhelper.add_to_path('uni;sub.p1.a1.g2:candidate(student1).d1:ends(70)') content, response = self._getas('student1', only='deadline_not_expired') self.assertEquals(response.status_code, 200) self.assertEquals(len(content), 1) self.assertEquals(content[0]['name'], 'g2') self.assertEquals(content[0]['active_deadline']['deadline_expired'], False) def test_hard_deadlines(self): # Add 2 assignments to the active period: # - one hard # - 2 groups, one after deadline # - one soft # - 2 groups, one after deadline self.testhelper.add_to_path('uni;sub.p1.a1.g1:candidate(student1).d1') # Expired deadline self.testhelper.add_to_path('uni;sub.p1.a1.g2:candidate(student1).d1:ends(80)') # In the future self.testhelper.add_to_path('uni;sub.p1.a2.g3:candidate(student1).d1') # Expired deadline self.testhelper.add_to_path('uni;sub.p1.a2.g4:candidate(student1).d1:ends(80)') # In the future self.assertTrue(self.testhelper.sub_p1_a1_g1_d1.deadline < datetime.now()) self.assertTrue(self.testhelper.sub_p1_a1_g2_d1.deadline > datetime.now()) self.assertTrue(self.testhelper.sub_p1_a2_g3_d1.deadline < datetime.now()) self.assertTrue(self.testhelper.sub_p1_a2_g4_d1.deadline > datetime.now()) self.testhelper.sub_p1_a2.deadline_handling = 1 # Hard deadlines on a2 self.testhelper.sub_p1_a2.save() content, response = self._getas('student1') self.assertEquals(response.status_code, 200) self.assertEquals(len(content), 3) groupnames = set([group['name'] for group in content]) self.assertEquals(groupnames, set(['g1', 'g2', 'g4']))
class TestRestSearchAdminContent(TestCase, AssertSearchResultMixin): def setUp(self): self.testhelper = TestHelper() self.testhelper.add(nodes='uni:admin(uniadmin):ln(Test Uni)', subjects=['sub:admin(subadmin):ln(Test Sub)'], periods=['p1:begins(-2):admin(p1admin):ln(Test P1)'], assignments=['a1:admin(a1admin):ln(Test A1)'], assignmentgroups=['TestGroup1:candidate(student1)'] ) self.client = RestClient() self.url = reverse('devilry_search_admincontent') def _getas(self, username, **data): self.client.login(username=username, password='******') return self.client.rest_get(self.url, **data) def _test_perms_topnodeorsuper(self, username): with HaystackTestSettings(): content, response = self._getas(username, search='Test') matches = content['matches'] self.assertEqual(len(matches), 5) self.assert_has_search_result(matches, type='core_node', title='Test Uni') self.assert_has_search_result(matches, type='core_subject', title='Test Sub') self.assert_has_search_result(matches, type='core_period', title='Test P1') self.assert_has_search_result(matches, type='core_assignment', title='Test A1') self.assert_has_search_result(matches, type='core_assignmentgroup', title='Test A1', students=['student1']) def test_perms_uniadmin(self): self._test_perms_topnodeorsuper('uniadmin') def test_perms_superuser(self): self.testhelper.create_superuser('superuser') self._test_perms_topnodeorsuper('superuser') def test_perms_subjectadmin(self): with HaystackTestSettings(): content, response = self._getas('subadmin', search='Test') matches = content['matches'] self.assertEqual(len(matches), 4) self.assert_has_search_result(matches, type='core_subject', title='Test Sub') self.assert_has_search_result(matches, type='core_period', title='Test P1') self.assert_has_search_result(matches, type='core_assignment', title='Test A1') self.assert_has_search_result(matches, type='core_assignmentgroup', title='Test A1', students=['student1']) def test_perms_periodadmin(self): with HaystackTestSettings(): content, response = self._getas('p1admin', search='Test') matches = content['matches'] self.assertEqual(len(matches), 3) self.assert_has_search_result(matches, type='core_period', title='Test P1') self.assert_has_search_result(matches, type='core_assignment', title='Test A1') self.assert_has_search_result(matches, type='core_assignmentgroup', title='Test A1', students=['student1']) def test_perms_assignmentadmin(self): with HaystackTestSettings(): content, response = self._getas('a1admin', search='Test') matches = content['matches'] self.assertEqual(len(matches), 2) self.assert_has_search_result(matches, type='core_assignment', title='Test A1') self.assert_has_search_result(matches, type='core_assignmentgroup', title='Test A1', students=['student1'])
class 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 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 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 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.')