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