--- a/test/unittest_rset.py Thu Apr 03 19:55:03 2014 +0200
+++ b/test/unittest_rset.py Thu Apr 03 19:55:11 2014 +0200
@@ -1,5 +1,5 @@
# coding: utf-8
-# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# copyright 2003-2014 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
#
# This file is part of CubicWeb.
@@ -27,7 +27,6 @@
from cubicweb.devtools.testlib import CubicWebTC
from cubicweb.rset import NotAnEntity, ResultSet, attr_desc_iterator
-
from cubicweb import NoResultError, MultipleResultsError
@@ -104,27 +103,27 @@
self.assertEqual(len(pickle.dumps(self.rset)), 392)
def test_build_url(self):
- req = self.request()
- baseurl = req.base_url()
- self.compare_urls(req.build_url('view', vid='foo', rql='yo'),
- '%sview?vid=foo&rql=yo' % baseurl)
- self.compare_urls(req.build_url('view', _restpath='task/title/go'),
- '%stask/title/go' % baseurl)
- #self.compare_urls(req.build_url('view', _restpath='/task/title/go'),
- # '%stask/title/go' % baseurl)
- # empty _restpath should not crash
- self.compare_urls(req.build_url('view', _restpath=''), baseurl)
- self.assertNotIn('https', req.build_url('view', vid='foo', rql='yo',
- __secure__=True))
- try:
- self.config.global_set_option('https-url', 'https://testing.fr/')
- self.assertTrue('https', req.build_url('view', vid='foo', rql='yo',
- __secure__=True))
- self.compare_urls(req.build_url('view', vid='foo', rql='yo',
- __secure__=True),
- '%sview?vid=foo&rql=yo' % req.base_url(secure=True))
- finally:
- self.config.global_set_option('https-url', None)
+ with self.admin_access.web_request() as req:
+ baseurl = req.base_url()
+ self.compare_urls(req.build_url('view', vid='foo', rql='yo'),
+ '%sview?vid=foo&rql=yo' % baseurl)
+ self.compare_urls(req.build_url('view', _restpath='task/title/go'),
+ '%stask/title/go' % baseurl)
+ #self.compare_urls(req.build_url('view', _restpath='/task/title/go'),
+ # '%stask/title/go' % baseurl)
+ # empty _restpath should not crash
+ self.compare_urls(req.build_url('view', _restpath=''), baseurl)
+ self.assertNotIn('https', req.build_url('view', vid='foo', rql='yo',
+ __secure__=True))
+ try:
+ self.config.global_set_option('https-url', 'https://testing.fr/')
+ self.assertTrue('https', req.build_url('view', vid='foo', rql='yo',
+ __secure__=True))
+ self.compare_urls(req.build_url('view', vid='foo', rql='yo',
+ __secure__=True),
+ '%sview?vid=foo&rql=yo' % req.base_url(secure=True))
+ finally:
+ self.config.global_set_option('https-url', None)
def test_build(self):
@@ -139,88 +138,92 @@
rs = ResultSet([[12000, 'adim'], [13000, 'syt'], [14000, 'nico']],
'Any U,L where U is CWUser, U login L',
description=[['CWUser', 'String']] * 3)
- rs.req = self.request()
- rs.vreg = self.vreg
- self.assertEqual(rs.limit(2).rows, [[12000, 'adim'], [13000, 'syt']])
- rs2 = rs.limit(2, offset=1)
- self.assertEqual(rs2.rows, [[13000, 'syt'], [14000, 'nico']])
- self.assertEqual(rs2.get_entity(0, 0).cw_row, 0)
- self.assertEqual(rs.limit(2, offset=2).rows, [[14000, 'nico']])
- self.assertEqual(rs.limit(2, offset=3).rows, [])
+ with self.admin_access.web_request() as req:
+ rs.req = req
+ rs.vreg = self.vreg
+ self.assertEqual(rs.limit(2).rows, [[12000, 'adim'], [13000, 'syt']])
+ rs2 = rs.limit(2, offset=1)
+ self.assertEqual(rs2.rows, [[13000, 'syt'], [14000, 'nico']])
+ self.assertEqual(rs2.get_entity(0, 0).cw_row, 0)
+ self.assertEqual(rs.limit(2, offset=2).rows, [[14000, 'nico']])
+ self.assertEqual(rs.limit(2, offset=3).rows, [])
def test_limit_2(self):
- req = self.request()
- # drop user from cache for the sake of this test
- req.drop_entity_cache(req.user.eid)
- rs = req.execute('Any E,U WHERE E is CWEType, E created_by U')
- # get entity on row 9. This will fill its created_by relation cache,
- # with cwuser on row 9 as well
- e1 = rs.get_entity(9, 0)
- # get entity on row 10. This will fill its created_by relation cache,
- # with cwuser built on row 9
- e2 = rs.get_entity(10, 0)
- # limit result set from row 10
- rs.limit(1, 10, inplace=True)
- # get back eid
- e = rs.get_entity(0, 0)
- self.assertTrue(e2 is e)
- # rs.limit has properly removed cwuser for request cache, but it's
- # still referenced by e/e2 relation cache
- u = e.created_by[0]
- # now ensure this doesn't trigger IndexError because cwuser.cw_row is 9
- # while now rset has only one row
- u.cw_rset[u.cw_row]
+ with self.admin_access.web_request() as req:
+ # drop user from cache for the sake of this test
+ req.drop_entity_cache(req.user.eid)
+ rs = req.execute('Any E,U WHERE E is CWEType, E created_by U')
+ # get entity on row 9. This will fill its created_by relation cache,
+ # with cwuser on row 9 as well
+ e1 = rs.get_entity(9, 0)
+ # get entity on row 10. This will fill its created_by relation cache,
+ # with cwuser built on row 9
+ e2 = rs.get_entity(10, 0)
+ # limit result set from row 10
+ rs.limit(1, 10, inplace=True)
+ # get back eid
+ e = rs.get_entity(0, 0)
+ self.assertTrue(e2 is e)
+ # rs.limit has properly removed cwuser for request cache, but it's
+ # still referenced by e/e2 relation cache
+ u = e.created_by[0]
+ # now ensure this doesn't trigger IndexError because cwuser.cw_row is 9
+ # while now rset has only one row
+ u.cw_rset[u.cw_row]
def test_filter(self):
rs = ResultSet([[12000, 'adim'], [13000, 'syt'], [14000, 'nico']],
'Any U,L where U is CWUser, U login L',
description=[['CWUser', 'String']] * 3)
- rs.req = self.request()
- rs.vreg = self.vreg
- def test_filter(entity):
- return entity.login != 'nico'
+ with self.admin_access.web_request() as req:
+ rs.req = req
+ rs.vreg = self.vreg
+ def test_filter(entity):
+ return entity.login != 'nico'
- rs2 = rs.filtered_rset(test_filter)
- self.assertEqual(len(rs2), 2)
- self.assertEqual([login for _, login in rs2], ['adim', 'syt'])
- self.assertEqual(rs2.description, rs.description[1:])
+ rs2 = rs.filtered_rset(test_filter)
+ self.assertEqual(len(rs2), 2)
+ self.assertEqual([login for _, login in rs2], ['adim', 'syt'])
+ self.assertEqual(rs2.description, rs.description[1:])
def test_transform(self):
rs = ResultSet([[12, 'adim'], [13, 'syt'], [14, 'nico']],
'Any U,L where U is CWUser, U login L',
description=[['CWUser', 'String']] * 3)
- rs.req = self.request()
- def test_transform(row, desc):
- return row[1:], desc[1:]
- rs2 = rs.transformed_rset(test_transform)
+ with self.admin_access.web_request() as req:
+ rs.req = req
+ def test_transform(row, desc):
+ return row[1:], desc[1:]
+ rs2 = rs.transformed_rset(test_transform)
- self.assertEqual(len(rs2), 3)
- self.assertEqual(list(rs2), [['adim'],['syt'],['nico']])
+ self.assertEqual(len(rs2), 3)
+ self.assertEqual(list(rs2), [['adim'],['syt'],['nico']])
def test_sort(self):
rs = ResultSet([[12000, 'adim'], [13000, 'syt'], [14000, 'nico']],
'Any U,L where U is CWUser, U login L',
description=[['CWUser', 'String']] * 3)
- rs.req = self.request()
- rs.vreg = self.vreg
+ with self.admin_access.web_request() as req:
+ rs.req = req
+ rs.vreg = self.vreg
- rs2 = rs.sorted_rset(lambda e:e.cw_attr_cache['login'])
- self.assertEqual(len(rs2), 3)
- self.assertEqual([login for _, login in rs2], ['adim', 'nico', 'syt'])
- # make sure rs is unchanged
- self.assertEqual([login for _, login in rs], ['adim', 'syt', 'nico'])
+ rs2 = rs.sorted_rset(lambda e:e.cw_attr_cache['login'])
+ self.assertEqual(len(rs2), 3)
+ self.assertEqual([login for _, login in rs2], ['adim', 'nico', 'syt'])
+ # make sure rs is unchanged
+ self.assertEqual([login for _, login in rs], ['adim', 'syt', 'nico'])
- rs2 = rs.sorted_rset(lambda e:e.cw_attr_cache['login'], reverse=True)
- self.assertEqual(len(rs2), 3)
- self.assertEqual([login for _, login in rs2], ['syt', 'nico', 'adim'])
- # make sure rs is unchanged
- self.assertEqual([login for _, login in rs], ['adim', 'syt', 'nico'])
+ rs2 = rs.sorted_rset(lambda e:e.cw_attr_cache['login'], reverse=True)
+ self.assertEqual(len(rs2), 3)
+ self.assertEqual([login for _, login in rs2], ['syt', 'nico', 'adim'])
+ # make sure rs is unchanged
+ self.assertEqual([login for _, login in rs], ['adim', 'syt', 'nico'])
- rs3 = rs.sorted_rset(lambda row: row[1], col=-1)
- self.assertEqual(len(rs3), 3)
- self.assertEqual([login for _, login in rs3], ['adim', 'nico', 'syt'])
- # make sure rs is unchanged
- self.assertEqual([login for _, login in rs], ['adim', 'syt', 'nico'])
+ rs3 = rs.sorted_rset(lambda row: row[1], col=-1)
+ self.assertEqual(len(rs3), 3)
+ self.assertEqual([login for _, login in rs3], ['adim', 'nico', 'syt'])
+ # make sure rs is unchanged
+ self.assertEqual([login for _, login in rs], ['adim', 'syt', 'nico'])
def test_split(self):
rs = ResultSet([[12000, 'adim', u'Adim chez les pinguins'],
@@ -231,40 +234,41 @@
'Any U, L, T WHERE U is CWUser, U login L,'\
'D created_by U, D title T',
description=[['CWUser', 'String', 'String']] * 5)
- rs.req = self.request()
- rs.vreg = self.vreg
- rsets = rs.split_rset(lambda e:e.cw_attr_cache['login'])
- self.assertEqual(len(rsets), 3)
- self.assertEqual([login for _, login,_ in rsets[0]], ['adim', 'adim'])
- self.assertEqual([login for _, login,_ in rsets[1]], ['syt'])
- self.assertEqual([login for _, login,_ in rsets[2]], ['nico', 'nico'])
- # make sure rs is unchanged
- self.assertEqual([login for _, login,_ in rs], ['adim', 'adim', 'syt', 'nico', 'nico'])
+ with self.admin_access.web_request() as req:
+ rs.req = req
+ rs.vreg = self.vreg
+ rsets = rs.split_rset(lambda e:e.cw_attr_cache['login'])
+ self.assertEqual(len(rsets), 3)
+ self.assertEqual([login for _, login,_ in rsets[0]], ['adim', 'adim'])
+ self.assertEqual([login for _, login,_ in rsets[1]], ['syt'])
+ self.assertEqual([login for _, login,_ in rsets[2]], ['nico', 'nico'])
+ # make sure rs is unchanged
+ self.assertEqual([login for _, login,_ in rs], ['adim', 'adim', 'syt', 'nico', 'nico'])
- rsets = rs.split_rset(lambda e:e.cw_attr_cache['login'], return_dict=True)
- self.assertEqual(len(rsets), 3)
- self.assertEqual([login for _, login,_ in rsets['nico']], ['nico', 'nico'])
- self.assertEqual([login for _, login,_ in rsets['adim']], ['adim', 'adim'])
- self.assertEqual([login for _, login,_ in rsets['syt']], ['syt'])
- # make sure rs is unchanged
- self.assertEqual([login for _, login,_ in rs], ['adim', 'adim', 'syt', 'nico', 'nico'])
+ rsets = rs.split_rset(lambda e:e.cw_attr_cache['login'], return_dict=True)
+ self.assertEqual(len(rsets), 3)
+ self.assertEqual([login for _, login,_ in rsets['nico']], ['nico', 'nico'])
+ self.assertEqual([login for _, login,_ in rsets['adim']], ['adim', 'adim'])
+ self.assertEqual([login for _, login,_ in rsets['syt']], ['syt'])
+ # make sure rs is unchanged
+ self.assertEqual([login for _, login,_ in rs], ['adim', 'adim', 'syt', 'nico', 'nico'])
- rsets = rs.split_rset(lambda s: s.count('d'), col=2)
- self.assertEqual(len(rsets), 2)
- self.assertEqual([title for _, _, title in rsets[0]],
- [u"Adim chez les pinguins",
- u"Jardiner facile",
- u"L'épluchage du castor commun",])
- self.assertEqual([title for _, _, title in rsets[1]],
- [u"Le carrelage en 42 leçons",
- u"La tarte tatin en 15 minutes",])
- # make sure rs is unchanged
- self.assertEqual([title for _, _, title in rs],
- [u'Adim chez les pinguins',
- u'Jardiner facile',
- u'Le carrelage en 42 leçons',
- u'La tarte tatin en 15 minutes',
- u"L'épluchage du castor commun"])
+ rsets = rs.split_rset(lambda s: s.count('d'), col=2)
+ self.assertEqual(len(rsets), 2)
+ self.assertEqual([title for _, _, title in rsets[0]],
+ [u"Adim chez les pinguins",
+ u"Jardiner facile",
+ u"L'épluchage du castor commun",])
+ self.assertEqual([title for _, _, title in rsets[1]],
+ [u"Le carrelage en 42 leçons",
+ u"La tarte tatin en 15 minutes",])
+ # make sure rs is unchanged
+ self.assertEqual([title for _, _, title in rs],
+ [u'Adim chez les pinguins',
+ u'Jardiner facile',
+ u'Le carrelage en 42 leçons',
+ u'La tarte tatin en 15 minutes',
+ u"L'épluchage du castor commun"])
def test_cached_syntax_tree(self):
"""make sure syntax tree is cached"""
@@ -273,268 +277,291 @@
self.assert_(rqlst1 is rqlst2)
def test_get_entity_simple(self):
- self.request().create_entity('CWUser', login=u'adim', upassword='adim',
- surname=u'di mascio', firstname=u'adrien')
- self.cnx.drop_entity_cache()
- e = self.execute('Any X,T WHERE X login "adim", X surname T').get_entity(0, 0)
- self.assertEqual(e.cw_attr_cache['surname'], 'di mascio')
- self.assertRaises(KeyError, e.cw_attr_cache.__getitem__, 'firstname')
- self.assertRaises(KeyError, e.cw_attr_cache.__getitem__, 'creation_date')
- self.assertEqual(pprelcachedict(e._cw_related_cache), [])
- e.complete()
- self.assertEqual(e.cw_attr_cache['firstname'], 'adrien')
- self.assertEqual(pprelcachedict(e._cw_related_cache), [])
+ with self.admin_access.web_request() as req:
+ req.create_entity('CWUser', login=u'adim', upassword='adim',
+ surname=u'di mascio', firstname=u'adrien')
+ req.cnx.drop_entity_cache()
+ e = req.execute('Any X,T WHERE X login "adim", X surname T').get_entity(0, 0)
+ self.assertEqual(e.cw_attr_cache['surname'], 'di mascio')
+ self.assertRaises(KeyError, e.cw_attr_cache.__getitem__, 'firstname')
+ self.assertRaises(KeyError, e.cw_attr_cache.__getitem__, 'creation_date')
+ self.assertEqual(pprelcachedict(e._cw_related_cache), [])
+ e.complete()
+ self.assertEqual(e.cw_attr_cache['firstname'], 'adrien')
+ self.assertEqual(pprelcachedict(e._cw_related_cache), [])
def test_get_entity_advanced(self):
- self.request().create_entity('Bookmark', title=u'zou', path=u'/view')
- self.cnx.drop_entity_cache()
- self.execute('SET X bookmarked_by Y WHERE X is Bookmark, Y login "anon"')
- rset = self.execute('Any X,Y,XT,YN WHERE X bookmarked_by Y, X title XT, Y login YN')
+ with self.admin_access.web_request() as req:
+ req.create_entity('Bookmark', title=u'zou', path=u'/view')
+ req.cnx.drop_entity_cache()
+ req.execute('SET X bookmarked_by Y WHERE X is Bookmark, Y login "anon"')
+ rset = req.execute('Any X,Y,XT,YN WHERE X bookmarked_by Y, X title XT, Y login YN')
- e = rset.get_entity(0, 0)
- self.assertEqual(e.cw_row, 0)
- self.assertEqual(e.cw_col, 0)
- self.assertEqual(e.cw_attr_cache['title'], 'zou')
- self.assertRaises(KeyError, e.cw_attr_cache.__getitem__, 'path')
- self.assertEqual(e.view('text'), 'zou')
- self.assertEqual(pprelcachedict(e._cw_related_cache), [])
+ e = rset.get_entity(0, 0)
+ self.assertEqual(e.cw_row, 0)
+ self.assertEqual(e.cw_col, 0)
+ self.assertEqual(e.cw_attr_cache['title'], 'zou')
+ self.assertRaises(KeyError, e.cw_attr_cache.__getitem__, 'path')
+ self.assertEqual(e.view('text'), 'zou')
+ self.assertEqual(pprelcachedict(e._cw_related_cache), [])
- e = rset.get_entity(0, 1)
- self.assertEqual(e.cw_row, 0)
- self.assertEqual(e.cw_col, 1)
- self.assertEqual(e.cw_attr_cache['login'], 'anon')
- self.assertRaises(KeyError, e.cw_attr_cache.__getitem__, 'firstname')
- self.assertEqual(pprelcachedict(e._cw_related_cache),
- [])
- e.complete()
- self.assertEqual(e.cw_attr_cache['firstname'], None)
- self.assertEqual(e.view('text'), 'anon')
- self.assertEqual(pprelcachedict(e._cw_related_cache),
- [])
+ e = rset.get_entity(0, 1)
+ self.assertEqual(e.cw_row, 0)
+ self.assertEqual(e.cw_col, 1)
+ self.assertEqual(e.cw_attr_cache['login'], 'anon')
+ self.assertRaises(KeyError, e.cw_attr_cache.__getitem__, 'firstname')
+ self.assertEqual(pprelcachedict(e._cw_related_cache),
+ [])
+ e.complete()
+ self.assertEqual(e.cw_attr_cache['firstname'], None)
+ self.assertEqual(e.view('text'), 'anon')
+ self.assertEqual(pprelcachedict(e._cw_related_cache),
+ [])
- self.assertRaises(NotAnEntity, rset.get_entity, 0, 2)
- self.assertRaises(NotAnEntity, rset.get_entity, 0, 3)
+ self.assertRaises(NotAnEntity, rset.get_entity, 0, 2)
+ self.assertRaises(NotAnEntity, rset.get_entity, 0, 3)
def test_get_entity_relation_cache_compt(self):
- rset = self.execute('Any X,S WHERE X in_state S, X login "anon"')
- e = rset.get_entity(0, 0)
- seid = self.execute('State X WHERE X name "activated"')[0][0]
- # for_user / in_group are prefetched in CWUser __init__, in_state should
- # be filed from our query rset
- self.assertEqual(pprelcachedict(e._cw_related_cache),
- [('in_state_subject', [seid])])
+ with self.admin_access.web_request() as req:
+ rset = req.execute('Any X,S WHERE X in_state S, X login "anon"')
+ e = rset.get_entity(0, 0)
+ seid = req.execute('State X WHERE X name "activated"')[0][0]
+ # for_user / in_group are prefetched in CWUser __init__, in_state should
+ # be filed from our query rset
+ self.assertEqual(pprelcachedict(e._cw_related_cache),
+ [('in_state_subject', [seid])])
def test_get_entity_advanced_prefilled_cache(self):
- e = self.request().create_entity('Bookmark', title=u'zou', path=u'path')
- self.commit()
- rset = self.execute('Any X,U,S,XT,UL,SN WHERE X created_by U, U in_state S, '
- 'X title XT, S name SN, U login UL, X eid %s' % e.eid)
- e = rset.get_entity(0, 0)
- self.assertEqual(e.cw_attr_cache['title'], 'zou')
- self.assertEqual(pprelcachedict(e._cw_related_cache),
- [('created_by_subject', [self.user().eid])])
- # first level of recursion
- u = e.created_by[0]
- self.assertEqual(u.cw_attr_cache['login'], 'admin')
- self.assertRaises(KeyError, u.cw_attr_cache.__getitem__, 'firstname')
- # second level of recursion
- s = u.in_state[0]
- self.assertEqual(s.cw_attr_cache['name'], 'activated')
- self.assertRaises(KeyError, s.cw_attr_cache.__getitem__, 'description')
+ with self.admin_access.web_request() as req:
+ e = req.create_entity('Bookmark', title=u'zou', path=u'path')
+ req.cnx.commit()
+ rset = req.execute('Any X,U,S,XT,UL,SN WHERE X created_by U, U in_state S, '
+ 'X title XT, S name SN, U login UL, X eid %s' % e.eid)
+ e = rset.get_entity(0, 0)
+ self.assertEqual(e.cw_attr_cache['title'], 'zou')
+ self.assertEqual(pprelcachedict(e._cw_related_cache),
+ [('created_by_subject', [req.user.eid])])
+ # first level of recursion
+ u = e.created_by[0]
+ self.assertEqual(u.cw_attr_cache['login'], 'admin')
+ self.assertRaises(KeyError, u.cw_attr_cache.__getitem__, 'firstname')
+ # second level of recursion
+ s = u.in_state[0]
+ self.assertEqual(s.cw_attr_cache['name'], 'activated')
+ self.assertRaises(KeyError, s.cw_attr_cache.__getitem__, 'description')
def test_get_entity_cache_with_left_outer_join(self):
- eid = self.execute('INSERT CWUser E: E login "joe", E upassword "joe", E in_group G '
- 'WHERE G name "users"')[0][0]
- rset = self.execute('Any X,E WHERE X eid %(x)s, X primary_email E?', {'x': eid})
- e = rset.get_entity(0, 0)
- # if any of the assertion below fails with a KeyError, the relation is not cached
- # related entities should be an empty list
- self.assertEqual(e._cw_related_cache['primary_email_subject'][True], ())
- # related rset should be an empty rset
- cached = e._cw_related_cache['primary_email_subject'][False]
- self.assertIsInstance(cached, ResultSet)
- self.assertEqual(cached.rowcount, 0)
+ with self.admin_access.web_request() as req:
+ eid = req.execute('INSERT CWUser E: E login "joe", E upassword "joe", E in_group G '
+ 'WHERE G name "users"')[0][0]
+ rset = req.execute('Any X,E WHERE X eid %(x)s, X primary_email E?', {'x': eid})
+ e = rset.get_entity(0, 0)
+ # if any of the assertion below fails with a KeyError, the relation is not cached
+ # related entities should be an empty list
+ self.assertEqual(e._cw_related_cache['primary_email_subject'][True], ())
+ # related rset should be an empty rset
+ cached = e._cw_related_cache['primary_email_subject'][False]
+ self.assertIsInstance(cached, ResultSet)
+ self.assertEqual(cached.rowcount, 0)
def test_get_entity_union(self):
- e = self.request().create_entity('Bookmark', title=u'manger', path=u'path')
- self.cnx.drop_entity_cache()
- rset = self.execute('Any X,N ORDERBY N WITH X,N BEING '
- '((Any X,N WHERE X is Bookmark, X title N)'
- ' UNION '
- ' (Any X,N WHERE X is CWGroup, X name N))')
- expected = (('CWGroup', 'guests'), ('CWGroup', 'managers'),
- ('Bookmark', 'manger'), ('CWGroup', 'owners'),
- ('CWGroup', 'users'))
- for entity in rset.entities(): # test get_entity for each row actually
- etype, n = expected[entity.cw_row]
- self.assertEqual(entity.cw_etype, etype)
- attr = etype == 'Bookmark' and 'title' or 'name'
- self.assertEqual(entity.cw_attr_cache[attr], n)
+ with self.admin_access.web_request() as req:
+ e = req.create_entity('Bookmark', title=u'manger', path=u'path')
+ req.cnx.drop_entity_cache()
+ rset = req.execute('Any X,N ORDERBY N WITH X,N BEING '
+ '((Any X,N WHERE X is Bookmark, X title N)'
+ ' UNION '
+ ' (Any X,N WHERE X is CWGroup, X name N))')
+ expected = (('CWGroup', 'guests'), ('CWGroup', 'managers'),
+ ('Bookmark', 'manger'), ('CWGroup', 'owners'),
+ ('CWGroup', 'users'))
+ for entity in rset.entities(): # test get_entity for each row actually
+ etype, n = expected[entity.cw_row]
+ self.assertEqual(entity.cw_etype, etype)
+ attr = etype == 'Bookmark' and 'title' or 'name'
+ self.assertEqual(entity.cw_attr_cache[attr], n)
def test_one(self):
- self.request().create_entity('CWUser', login=u'cdevienne',
- upassword=u'cdevienne',
- surname=u'de Vienne',
- firstname=u'Christophe')
- e = self.execute('Any X WHERE X login "cdevienne"').one()
-
- self.assertEqual(e.surname, u'de Vienne')
+ with self.admin_access.web_request() as req:
+ req.create_entity('CWUser', login=u'cdevienne',
+ upassword=u'cdevienne',
+ surname=u'de Vienne',
+ firstname=u'Christophe')
+ e = req.execute('Any X WHERE X login "cdevienne"').one()
- e = self.execute(
- 'Any X, N WHERE X login "cdevienne", X surname N').one()
- self.assertEqual(e.surname, u'de Vienne')
+ self.assertEqual(e.surname, u'de Vienne')
- e = self.execute(
- 'Any N, X WHERE X login "cdevienne", X surname N').one(col=1)
- self.assertEqual(e.surname, u'de Vienne')
+ e = req.execute(
+ 'Any X, N WHERE X login "cdevienne", X surname N').one()
+ self.assertEqual(e.surname, u'de Vienne')
+
+ e = req.execute(
+ 'Any N, X WHERE X login "cdevienne", X surname N').one(col=1)
+ self.assertEqual(e.surname, u'de Vienne')
def test_one_no_rows(self):
- with self.assertRaises(NoResultError):
- self.execute('Any X WHERE X login "patanok"').one()
+ with self.admin_access.web_request() as req:
+ with self.assertRaises(NoResultError):
+ req.execute('Any X WHERE X login "patanok"').one()
def test_one_multiple_rows(self):
- self.request().create_entity(
- 'CWUser', login=u'cdevienne', upassword=u'cdevienne',
- surname=u'de Vienne', firstname=u'Christophe')
+ with self.admin_access.web_request() as req:
+ req.create_entity(
+ 'CWUser', login=u'cdevienne', upassword=u'cdevienne',
+ surname=u'de Vienne', firstname=u'Christophe')
- self.request().create_entity(
- 'CWUser', login=u'adim', upassword='adim', surname=u'di mascio',
- firstname=u'adrien')
+ req.create_entity(
+ 'CWUser', login=u'adim', upassword='adim', surname=u'di mascio',
+ firstname=u'adrien')
- with self.assertRaises(MultipleResultsError):
- self.execute('Any X WHERE X is CWUser').one()
+ with self.assertRaises(MultipleResultsError):
+ req.execute('Any X WHERE X is CWUser').one()
def test_related_entity_optional(self):
- e = self.request().create_entity('Bookmark', title=u'aaaa', path=u'path')
- rset = self.execute('Any B,U,L WHERE B bookmarked_by U?, U login L')
- entity, rtype = rset.related_entity(0, 2)
- self.assertEqual(entity, None)
- self.assertEqual(rtype, None)
+ with self.admin_access.web_request() as req:
+ e = req.create_entity('Bookmark', title=u'aaaa', path=u'path')
+ rset = req.execute('Any B,U,L WHERE B bookmarked_by U?, U login L')
+ entity, rtype = rset.related_entity(0, 2)
+ self.assertEqual(entity, None)
+ self.assertEqual(rtype, None)
def test_related_entity_union_subquery_1(self):
- e = self.request().create_entity('Bookmark', title=u'aaaa', path=u'path')
- rset = self.execute('Any X,N ORDERBY N WITH X,N BEING '
- '((Any X,N WHERE X is CWGroup, X name N)'
- ' UNION '
- ' (Any X,N WHERE X is Bookmark, X title N))')
- entity, rtype = rset.related_entity(0, 1)
- self.assertEqual(entity.eid, e.eid)
- self.assertEqual(rtype, 'title')
- self.assertEqual(entity.title, 'aaaa')
- entity, rtype = rset.related_entity(1, 1)
- self.assertEqual(entity.cw_etype, 'CWGroup')
- self.assertEqual(rtype, 'name')
- self.assertEqual(entity.name, 'guests')
+ with self.admin_access.web_request() as req:
+ e = req.create_entity('Bookmark', title=u'aaaa', path=u'path')
+ rset = req.execute('Any X,N ORDERBY N WITH X,N BEING '
+ '((Any X,N WHERE X is CWGroup, X name N)'
+ ' UNION '
+ ' (Any X,N WHERE X is Bookmark, X title N))')
+ entity, rtype = rset.related_entity(0, 1)
+ self.assertEqual(entity.eid, e.eid)
+ self.assertEqual(rtype, 'title')
+ self.assertEqual(entity.title, 'aaaa')
+ entity, rtype = rset.related_entity(1, 1)
+ self.assertEqual(entity.cw_etype, 'CWGroup')
+ self.assertEqual(rtype, 'name')
+ self.assertEqual(entity.name, 'guests')
def test_related_entity_union_subquery_2(self):
- e = self.request().create_entity('Bookmark', title=u'aaaa', path=u'path')
- rset = self.execute('Any X,N ORDERBY N WHERE X is Bookmark WITH X,N BEING '
- '((Any X,N WHERE X is CWGroup, X name N)'
- ' UNION '
- ' (Any X,N WHERE X is Bookmark, X title N))')
- entity, rtype = rset.related_entity(0, 1)
- self.assertEqual(entity.eid, e.eid)
- self.assertEqual(rtype, 'title')
- self.assertEqual(entity.title, 'aaaa')
+ with self.admin_access.web_request() as req:
+ e = req.create_entity('Bookmark', title=u'aaaa', path=u'path')
+ rset = req.execute('Any X,N ORDERBY N WHERE X is Bookmark WITH X,N BEING '
+ '((Any X,N WHERE X is CWGroup, X name N)'
+ ' UNION '
+ ' (Any X,N WHERE X is Bookmark, X title N))')
+ entity, rtype = rset.related_entity(0, 1)
+ self.assertEqual(entity.eid, e.eid)
+ self.assertEqual(rtype, 'title')
+ self.assertEqual(entity.title, 'aaaa')
def test_related_entity_union_subquery_3(self):
- e = self.request().create_entity('Bookmark', title=u'aaaa', path=u'path')
- rset = self.execute('Any X,N ORDERBY N WITH N,X BEING '
- '((Any N,X WHERE X is CWGroup, X name N)'
- ' UNION '
- ' (Any N,X WHERE X is Bookmark, X title N))')
- entity, rtype = rset.related_entity(0, 1)
- self.assertEqual(entity.eid, e.eid)
- self.assertEqual(rtype, 'title')
- self.assertEqual(entity.title, 'aaaa')
+ with self.admin_access.web_request() as req:
+ e = req.create_entity('Bookmark', title=u'aaaa', path=u'path')
+ rset = req.execute('Any X,N ORDERBY N WITH N,X BEING '
+ '((Any N,X WHERE X is CWGroup, X name N)'
+ ' UNION '
+ ' (Any N,X WHERE X is Bookmark, X title N))')
+ entity, rtype = rset.related_entity(0, 1)
+ self.assertEqual(entity.eid, e.eid)
+ self.assertEqual(rtype, 'title')
+ self.assertEqual(entity.title, 'aaaa')
def test_related_entity_union_subquery_4(self):
- e = self.request().create_entity('Bookmark', title=u'aaaa', path=u'path')
- rset = self.execute('Any X,X, N ORDERBY N WITH X,N BEING '
- '((Any X,N WHERE X is CWGroup, X name N)'
- ' UNION '
- ' (Any X,N WHERE X is Bookmark, X title N))')
- entity, rtype = rset.related_entity(0, 2)
- self.assertEqual(entity.eid, e.eid)
- self.assertEqual(rtype, 'title')
- self.assertEqual(entity.title, 'aaaa')
+ with self.admin_access.web_request() as req:
+ e = req.create_entity('Bookmark', title=u'aaaa', path=u'path')
+ rset = req.execute('Any X,X, N ORDERBY N WITH X,N BEING '
+ '((Any X,N WHERE X is CWGroup, X name N)'
+ ' UNION '
+ ' (Any X,N WHERE X is Bookmark, X title N))')
+ entity, rtype = rset.related_entity(0, 2)
+ self.assertEqual(entity.eid, e.eid)
+ self.assertEqual(rtype, 'title')
+ self.assertEqual(entity.title, 'aaaa')
def test_related_entity_trap_subquery(self):
- req = self.request()
- req.create_entity('Bookmark', title=u'test bookmark', path=u'')
- self.execute('SET B bookmarked_by U WHERE U login "admin"')
- rset = self.execute('Any B,T,L WHERE B bookmarked_by U, U login L '
- 'WITH B,T BEING (Any B,T WHERE B is Bookmark, B title T)')
- rset.related_entity(0, 2)
+ with self.admin_access.web_request() as req:
+ req.create_entity('Bookmark', title=u'test bookmark', path=u'')
+ req.execute('SET B bookmarked_by U WHERE U login "admin"')
+ rset = req.execute('Any B,T,L WHERE B bookmarked_by U, U login L '
+ 'WITH B,T BEING (Any B,T WHERE B is Bookmark, B title T)')
+ rset.related_entity(0, 2)
def test_related_entity_subquery_outerjoin(self):
- rset = self.execute('Any X,S,L WHERE X in_state S '
- 'WITH X, L BEING (Any X,MAX(L) GROUPBY X '
- 'WHERE X is CWUser, T? wf_info_for X, T creation_date L)')
- self.assertEqual(len(rset), 2)
- rset.related_entity(0, 1)
- rset.related_entity(0, 2)
+ with self.admin_access.web_request() as req:
+ rset = req.execute('Any X,S,L WHERE X in_state S '
+ 'WITH X, L BEING (Any X,MAX(L) GROUPBY X '
+ 'WHERE X is CWUser, T? wf_info_for X, T creation_date L)')
+ self.assertEqual(len(rset), 2)
+ rset.related_entity(0, 1)
+ rset.related_entity(0, 2)
def test_entities(self):
- rset = self.execute('Any U,G WHERE U in_group G')
- # make sure we have at least one element
- self.assertTrue(rset)
- self.assertEqual(set(e.e_schema.type for e in rset.entities(0)),
- set(['CWUser',]))
- self.assertEqual(set(e.e_schema.type for e in rset.entities(1)),
- set(['CWGroup',]))
+ with self.admin_access.web_request() as req:
+ rset = req.execute('Any U,G WHERE U in_group G')
+ # make sure we have at least one element
+ self.assertTrue(rset)
+ self.assertEqual(set(e.e_schema.type for e in rset.entities(0)),
+ set(['CWUser',]))
+ self.assertEqual(set(e.e_schema.type for e in rset.entities(1)),
+ set(['CWGroup',]))
def test_iter_rows_with_entities(self):
- rset = self.execute('Any U,UN,G,GN WHERE U in_group G, U login UN, G name GN')
- # make sure we have at least one element
- self.assertTrue(rset)
- out = list(rset.iter_rows_with_entities())[0]
- self.assertEqual( out[0].login, out[1] )
- self.assertEqual( out[2].name, out[3] )
+ with self.admin_access.web_request() as req:
+ rset = req.execute('Any U,UN,G,GN WHERE U in_group G, U login UN, G name GN')
+ # make sure we have at least one element
+ self.assertTrue(rset)
+ out = list(rset.iter_rows_with_entities())[0]
+ self.assertEqual( out[0].login, out[1] )
+ self.assertEqual( out[2].name, out[3] )
def test_printable_rql(self):
- rset = self.execute(u'CWEType X WHERE X final FALSE')
- self.assertEqual(rset.printable_rql(),
- 'Any X WHERE X final FALSE, X is CWEType')
+ with self.admin_access.web_request() as req:
+ rset = req.execute(u'CWEType X WHERE X final FALSE')
+ self.assertEqual(rset.printable_rql(),
+ 'Any X WHERE X final FALSE, X is CWEType')
def test_searched_text(self):
- rset = self.execute(u'Any X WHERE X has_text "foobar"')
- self.assertEqual(rset.searched_text(), 'foobar')
- rset = self.execute(u'Any X WHERE X has_text %(text)s', {'text' : 'foo'})
- self.assertEqual(rset.searched_text(), 'foo')
+ with self.admin_access.web_request() as req:
+ rset = req.execute(u'Any X WHERE X has_text "foobar"')
+ self.assertEqual(rset.searched_text(), 'foobar')
+ rset = req.execute(u'Any X WHERE X has_text %(text)s', {'text' : 'foo'})
+ self.assertEqual(rset.searched_text(), 'foo')
def test_union_limited_rql(self):
- rset = self.execute('(Any X,N WHERE X is Bookmark, X title N)'
- ' UNION '
- '(Any X,N WHERE X is CWGroup, X name N)')
- rset.limit(2, 10, inplace=True)
- self.assertEqual(rset.limited_rql(),
- 'Any A,B LIMIT 2 OFFSET 10 '
- 'WITH A,B BEING ('
- '(Any X,N WHERE X is Bookmark, X title N) '
- 'UNION '
- '(Any X,N WHERE X is CWGroup, X name N)'
- ')')
+ with self.admin_access.web_request() as req:
+ rset = req.execute('(Any X,N WHERE X is Bookmark, X title N)'
+ ' UNION '
+ '(Any X,N WHERE X is CWGroup, X name N)')
+ rset.limit(2, 10, inplace=True)
+ self.assertEqual(rset.limited_rql(),
+ 'Any A,B LIMIT 2 OFFSET 10 '
+ 'WITH A,B BEING ('
+ '(Any X,N WHERE X is Bookmark, X title N) '
+ 'UNION '
+ '(Any X,N WHERE X is CWGroup, X name N)'
+ ')')
def test_count_users_by_date(self):
- rset = self.execute('Any D, COUNT(U) GROUPBY D WHERE U is CWUser, U creation_date D')
- self.assertEqual(rset.related_entity(0,0), (None, None))
+ with self.admin_access.web_request() as req:
+ rset = req.execute('Any D, COUNT(U) GROUPBY D WHERE U is CWUser, U creation_date D')
+ self.assertEqual(rset.related_entity(0,0), (None, None))
def test_str(self):
- rset = self.execute('(Any X,N WHERE X is CWGroup, X name N)')
- self.assertIsInstance(str(rset), basestring)
- self.assertEqual(len(str(rset).splitlines()), 1)
+ with self.admin_access.web_request() as req:
+ rset = req.execute('(Any X,N WHERE X is CWGroup, X name N)')
+ self.assertIsInstance(str(rset), basestring)
+ self.assertEqual(len(str(rset).splitlines()), 1)
def test_repr(self):
- rset = self.execute('(Any X,N WHERE X is CWGroup, X name N)')
- self.assertIsInstance(repr(rset), basestring)
- self.assertTrue(len(repr(rset).splitlines()) > 1)
+ with self.admin_access.web_request() as req:
+ rset = req.execute('(Any X,N WHERE X is CWGroup, X name N)')
+ self.assertIsInstance(repr(rset), basestring)
+ self.assertTrue(len(repr(rset).splitlines()) > 1)
- rset = self.execute('(Any X WHERE X is CWGroup, X name "managers")')
- self.assertIsInstance(str(rset), basestring)
- self.assertEqual(len(str(rset).splitlines()), 1)
+ rset = req.execute('(Any X WHERE X is CWGroup, X name "managers")')
+ self.assertIsInstance(str(rset), basestring)
+ self.assertEqual(len(str(rset).splitlines()), 1)
if __name__ == '__main__':