Mercurial Mercurial > pub > hg > cubicweb / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
web/test/unittest_views_basecontrollers.py
changeset 4292 3fc808b0490b
parent 4266 6bee6f0892e0
child 4389 14a993bc8d1e
equal deleted inserted replaced
4290:c2f15166f019 4292:3fc808b0490b 
    13 from cubicweb.view import STRICT_DOCTYPE
 
    13 from cubicweb.view import STRICT_DOCTYPE
 
    14 from cubicweb.devtools.testlib import CubicWebTC
 
    14 from cubicweb.devtools.testlib import CubicWebTC
 
    15 from cubicweb.uilib import rql_for_eid
 
    15 from cubicweb.uilib import rql_for_eid
 
    16 from cubicweb.web import INTERNAL_FIELD_VALUE, Redirect, RequestError
 
    16 from cubicweb.web import INTERNAL_FIELD_VALUE, Redirect, RequestError
 
    17 from cubicweb.entities.authobjs import CWUser
 
    17 from cubicweb.entities.authobjs import CWUser
 
    18 
    18 from cubicweb.web.views.editviews import get_pending_inserts, get_pending_deletes
 
    19 u = unicode
 
    19 u = unicode
 
    20 
    20 
       
    21 def req_form(user):
 
       
    22     return {'eid': [str(user.eid)],
 
       
    23             '_cw_edited_fields:%s' % user.eid: '_cw_generic_field',
 
       
    24             '__type:%s' % user.eid: user.__regid__
 
       
    25             }
 
    21 
    26 
    22 class EditControllerTC(CubicWebTC):
 
    27 class EditControllerTC(CubicWebTC):
 
    23     def setUp(self):
 
    28     def setUp(self):
 
    24         CubicWebTC.setUp(self)
 
    29         CubicWebTC.setUp(self)
 
    25         self.failUnless('users' in self.schema.eschema('CWGroup').get_groups('read'))
 
    30         self.failUnless('users' in self.schema.eschema('CWGroup').get_groups('read'))
 
   239 
   244 
   240     def test_req_pending_insert(self):
 
   245     def test_req_pending_insert(self):
 
   241         """make sure req's pending insertions are taken into account"""
 
   246         """make sure req's pending insertions are taken into account"""
 
   242         tmpgroup = self.request().create_entity('CWGroup', name=u"test")
 
   247         tmpgroup = self.request().create_entity('CWGroup', name=u"test")
 
   243         user = self.user()
 
   248         user = self.user()
 
   244         req = self.request()
 
   249         req = self.request(**req_form(user))
 
   245         req.set_session_data('pending_insert', set([(user.eid, 'in_group', tmpgroup.eid)]))
 
   250         req.set_session_data('pending_insert', set([(user.eid, 'in_group', tmpgroup.eid)]))
 
   246         path, params = self.expect_redirect_publish(req, 'edit')
 
   251         path, params = self.expect_redirect_publish(req, 'edit')
 
   247         usergroups = [gname for gname, in
 
   252         usergroups = [gname for gname, in
 
   248                       self.execute('Any N WHERE G name N, U in_group G, U eid %(u)s', {'u': user.eid})]
 
   253                       self.execute('Any N WHERE G name N, U in_group G, U eid %(u)s', {'u': user.eid})]
 
   249         self.assertUnorderedIterableEquals(usergroups, ['managers', 'test'])
 
   254         self.assertUnorderedIterableEquals(usergroups, ['managers', 'test'])
 
   250         self.assertEquals(req.get_pending_inserts(), [])
 
   255         self.assertEquals(get_pending_inserts(req), [])
 
   251 
   256 
   252 
   257 
   253     def test_req_pending_delete(self):
 
   258     def test_req_pending_delete(self):
 
   254         """make sure req's pending deletions are taken into account"""
 
   259         """make sure req's pending deletions are taken into account"""
 
   255         user = self.user()
 
   260         user = self.user()
 
   258         usergroups = [gname for gname, in
 
   263         usergroups = [gname for gname, in
 
   259                       self.execute('Any N WHERE G name N, U in_group G, U eid %(u)s', {'u': user.eid})]
 
   264                       self.execute('Any N WHERE G name N, U in_group G, U eid %(u)s', {'u': user.eid})]
 
   260         # just make sure everything was set correctly
 
   265         # just make sure everything was set correctly
 
   261         self.assertUnorderedIterableEquals(usergroups, ['managers', 'test'])
 
   266         self.assertUnorderedIterableEquals(usergroups, ['managers', 'test'])
 
   262         # now try to delete the relation
 
   267         # now try to delete the relation
 
   263         req = self.request()
 
   268         req = self.request(**req_form(user))
 
   264         req.set_session_data('pending_delete', set([(user.eid, 'in_group', groupeid)]))
 
   269         req.set_session_data('pending_delete', set([(user.eid, 'in_group', groupeid)]))
 
   265         path, params = self.expect_redirect_publish(req, 'edit')
 
   270         path, params = self.expect_redirect_publish(req, 'edit')
 
   266         usergroups = [gname for gname, in
 
   271         usergroups = [gname for gname, in
 
   267                       self.execute('Any N WHERE G name N, U in_group G, U eid %(u)s', {'u': user.eid})]
 
   272                       self.execute('Any N WHERE G name N, U in_group G, U eid %(u)s', {'u': user.eid})]
 
   268         self.assertUnorderedIterableEquals(usergroups, ['managers'])
 
   273         self.assertUnorderedIterableEquals(usergroups, ['managers'])
 
   269         self.assertEquals(req.get_pending_deletes(), [])
 
   274         self.assertEquals(get_pending_deletes(req), [])
 
   270 
   275 
   271     # def test_custom_attribute_handler(self):
 
   276     # def test_custom_attribute_handler(self):
 
   272     #     def custom_login_edit(self, formparams, value, relations):
 
   277     #     def custom_login_edit(self, formparams, value, relations):
 
   273     #         formparams['login'] = value.upper()
 
   278     #         formparams['login'] = value.upper()
 
   274     #         relations.append('X login %(login)s')
 
   279     #         relations.append('X login %(login)s')
 
   580         self.assertEquals(self.execute('Any N WHERE T tags P, P is CWUser, T name N').rows,
 
   585         self.assertEquals(self.execute('Any N WHERE T tags P, P is CWUser, T name N').rows,
 
   581                           [['javascript']])
 
   586                           [['javascript']])
 
   582 
   587 
   583     def test_pending_insertion(self):
 
   588     def test_pending_insertion(self):
 
   584         res, req = self.remote_call('add_pending_inserts', [['12', 'tags', '13']])
 
   589         res, req = self.remote_call('add_pending_inserts', [['12', 'tags', '13']])
 
   585         deletes = req.get_pending_deletes()
 
   590         deletes = get_pending_deletes(req)
 
   586         self.assertEquals(deletes, [])
 
   591         self.assertEquals(deletes, [])
 
   587         inserts = req.get_pending_inserts()
 
   592         inserts = get_pending_inserts(req)
 
   588         self.assertEquals(inserts, ['12:tags:13'])
 
   593         self.assertEquals(inserts, ['12:tags:13'])
 
   589         res, req = self.remote_call('add_pending_inserts', [['12', 'tags', '14']])
 
   594         res, req = self.remote_call('add_pending_inserts', [['12', 'tags', '14']])
 
   590         deletes = req.get_pending_deletes()
 
   595         deletes = get_pending_deletes(req)
 
   591         self.assertEquals(deletes, [])
 
   596         self.assertEquals(deletes, [])
 
   592         inserts = req.get_pending_inserts()
 
   597         inserts = get_pending_inserts(req)
 
   593         self.assertEquals(inserts, ['12:tags:13', '12:tags:14'])
 
   598         self.assertEquals(inserts, ['12:tags:13', '12:tags:14'])
 
   594         inserts = req.get_pending_inserts(12)
 
   599         inserts = get_pending_inserts(req, 12)
 
   595         self.assertEquals(inserts, ['12:tags:13', '12:tags:14'])
 
   600         self.assertEquals(inserts, ['12:tags:13', '12:tags:14'])
 
   596         inserts = req.get_pending_inserts(13)
 
   601         inserts = get_pending_inserts(req, 13)
 
   597         self.assertEquals(inserts, ['12:tags:13'])
 
   602         self.assertEquals(inserts, ['12:tags:13'])
 
   598         inserts = req.get_pending_inserts(14)
 
   603         inserts = get_pending_inserts(req, 14)
 
   599         self.assertEquals(inserts, ['12:tags:14'])
 
   604         self.assertEquals(inserts, ['12:tags:14'])
 
   600         req.remove_pending_operations()
 
   605         req.remove_pending_operations()
 
   601 
   606 
   602     def test_pending_deletion(self):
 
   607     def test_pending_deletion(self):
 
   603         res, req = self.remote_call('add_pending_delete', ['12', 'tags', '13'])
 
   608         res, req = self.remote_call('add_pending_delete', ['12', 'tags', '13'])
 
   604         inserts = req.get_pending_inserts()
 
   609         inserts = get_pending_inserts(req)
 
   605         self.assertEquals(inserts, [])
 
   610         self.assertEquals(inserts, [])
 
   606         deletes = req.get_pending_deletes()
 
   611         deletes = get_pending_deletes(req)
 
   607         self.assertEquals(deletes, ['12:tags:13'])
 
   612         self.assertEquals(deletes, ['12:tags:13'])
 
   608         res, req = self.remote_call('add_pending_delete', ['12', 'tags', '14'])
 
   613         res, req = self.remote_call('add_pending_delete', ['12', 'tags', '14'])
 
   609         inserts = req.get_pending_inserts()
 
   614         inserts = get_pending_inserts(req)
 
   610         self.assertEquals(inserts, [])
 
   615         self.assertEquals(inserts, [])
 
   611         deletes = req.get_pending_deletes()
 
   616         deletes = get_pending_deletes(req)
 
   612         self.assertEquals(deletes, ['12:tags:13', '12:tags:14'])
 
   617         self.assertEquals(deletes, ['12:tags:13', '12:tags:14'])
 
   613         deletes = req.get_pending_deletes(12)
 
   618         deletes = get_pending_deletes(req, 12)
 
   614         self.assertEquals(deletes, ['12:tags:13', '12:tags:14'])
 
   619         self.assertEquals(deletes, ['12:tags:13', '12:tags:14'])
 
   615         deletes = req.get_pending_deletes(13)
 
   620         deletes = get_pending_deletes(req, 13)
 
   616         self.assertEquals(deletes, ['12:tags:13'])
 
   621         self.assertEquals(deletes, ['12:tags:13'])
 
   617         deletes = req.get_pending_deletes(14)
 
   622         deletes = get_pending_deletes(req, 14)
 
   618         self.assertEquals(deletes, ['12:tags:14'])
 
   623         self.assertEquals(deletes, ['12:tags:14'])
 
   619         req.remove_pending_operations()
 
   624         req.remove_pending_operations()
 
   620 
   625 
   621     def test_remove_pending_operations(self):
 
   626     def test_remove_pending_operations(self):
 
   622         self.remote_call('add_pending_delete', ['12', 'tags', '13'])
 
   627         self.remote_call('add_pending_delete', ['12', 'tags', '13'])
 
   623         _, req = self.remote_call('add_pending_inserts', [['12', 'tags', '14']])
 
   628         _, req = self.remote_call('add_pending_inserts', [['12', 'tags', '14']])
 
   624         inserts = req.get_pending_inserts()
 
   629         inserts = get_pending_inserts(req)
 
   625         self.assertEquals(inserts, ['12:tags:14'])
 
   630         self.assertEquals(inserts, ['12:tags:14'])
 
   626         deletes = req.get_pending_deletes()
 
   631         deletes = get_pending_deletes(req)
 
   627         self.assertEquals(deletes, ['12:tags:13'])
 
   632         self.assertEquals(deletes, ['12:tags:13'])
 
   628         req.remove_pending_operations()
 
   633         req.remove_pending_operations()
 
   629         self.assertEquals(req.get_pending_deletes(), [])
 
   634         self.assertEquals(get_pending_deletes(req), [])
 
   630         self.assertEquals(req.get_pending_inserts(), [])
 
   635         self.assertEquals(get_pending_inserts(req), [])
 
   631 
   636 
   632 
   637 
   633     def test_add_inserts(self):
 
   638     def test_add_inserts(self):
 
   634         res, req = self.remote_call('add_pending_inserts',
 
   639         res, req = self.remote_call('add_pending_inserts',
 
   635                                     [('12', 'tags', '13'), ('12', 'tags', '14')])
 
   640                                     [('12', 'tags', '13'), ('12', 'tags', '14')])
 
   636         inserts = req.get_pending_inserts()
 
   641         inserts = get_pending_inserts(req)
 
   637         self.assertEquals(inserts, ['12:tags:13', '12:tags:14'])
 
   642         self.assertEquals(inserts, ['12:tags:13', '12:tags:14'])
 
   638         req.remove_pending_operations()
 
   643         req.remove_pending_operations()
 
   639 
   644 
   640 
   645 
   641     # silly tests
 
   646     # silly tests
cubicweb