Python RestClient.rest_get方法代码示例

# 需要导入模块: from devilry.utils.rest_testclient import RestClient [as 别名]
# 或者: from devilry.utils.rest_testclient.RestClient import rest_get [as 别名]
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='test')
        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)

# 需要导入模块: from devilry.utils.rest_testclient import RestClient [as 别名]
# 或者: from devilry.utils.rest_testclient.RestClient import rest_get [as 别名]
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='test')
        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='test')
        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')

# 需要导入模块: from devilry.utils.rest_testclient import RestClient [as 别名]
# 或者: from devilry.utils.rest_testclient.RestClient import rest_get [as 别名]
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='test')
        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'[email protected]'} 
        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)

# 需要导入模块: from devilry.utils.rest_testclient import RestClient [as 别名]
# 或者: from devilry.utils.rest_testclient.RestClient import rest_get [as 别名]
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="infadmin", password="test")
        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="fysadmin", password="test")
        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="super", password="test")
        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="nobody", password="test")
        content, response = self.client.rest_get(self._geturl())
        self.assertEquals(response.status_code, 200)
        self.assertEquals(content, [])

# 需要导入模块: from devilry.utils.rest_testclient import RestClient [as 别名]
# 或者: from devilry.utils.rest_testclient.RestClient import rest_get [as 别名]
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='test')
        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)

# 需要导入模块: from devilry.utils.rest_testclient import RestClient [as 别名]
# 或者: from devilry.utils.rest_testclient.RestClient import rest_get [as 别名]
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='test')
        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')

# 需要导入模块: from devilry.utils.rest_testclient import RestClient [as 别名]
# 或者: from devilry.utils.rest_testclient.RestClient import rest_get [as 别名]
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='test')
        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)

# 需要导入模块: from devilry.utils.rest_testclient import RestClient [as 别名]
# 或者: from devilry.utils.rest_testclient.RestClient import rest_get [as 别名]
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='test')
        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)

# 需要导入模块: from devilry.utils.rest_testclient import RestClient [as 别名]
# 或者: from devilry.utils.rest_testclient.RestClient import rest_get [as 别名]
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='test')
        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']))

# 需要导入模块: from devilry.utils.rest_testclient import RestClient [as 别名]
# 或者: from devilry.utils.rest_testclient.RestClient import rest_get [as 别名]
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='test')
        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)

# 需要导入模块: from devilry.utils.rest_testclient import RestClient [as 别名]
# 或者: from devilry.utils.rest_testclient.RestClient import rest_get [as 别名]
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='test')
        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)

# 需要导入模块: from devilry.utils.rest_testclient import RestClient [as 别名]
# 或者: from devilry.utils.rest_testclient.RestClient import rest_get [as 别名]
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='test')
        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)

# 需要导入模块: from devilry.utils.rest_testclient import RestClient [as 别名]
# 或者: from devilry.utils.rest_testclient.RestClient import rest_get [as 别名]
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='test')
        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'])
#.........这里部分代码省略.........

# 需要导入模块: from devilry.utils.rest_testclient import RestClient [as 别名]
# 或者: from devilry.utils.rest_testclient.RestClient import rest_get [as 别名]

#.........这里部分代码省略.........
        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='test')
        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': 'candidate1',
                                              'email': '[email protected]',
                                              'full_name': None})

        # Examiners
        self.assertEquals(len(content['examiners']), 1)
        examiner = content['examiners'][0]
        self.assertEquals(examiner['user'], {'id': self.testhelper.examiner1.id,
                                              'username': 'examiner1',
                                              'email': '[email protected]',
                                              '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)

# 需要导入模块: from devilry.utils.rest_testclient import RestClient [as 别名]
# 或者: from devilry.utils.rest_testclient.RestClient import rest_get [as 别名]
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='test')
        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
#.........这里部分代码省略.........