cubicweb: comparison test/unittest

equal deleted inserted replaced

-:48f468f33704
+:e4580e5f0703
 # FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 # details.
 #
 # You should have received a copy of the GNU Lesser General Public License along
 # with CubicWeb.  If not, see <http://www.gnu.org/licenses/>.
-"""unit tests for module cubicweb.utils
+"""unit tests for module cubicweb.utils"""
-"""
 from urlparse import urlsplit
 import pickle
 from rql import parse
 'Any C,P where C is Company, C employs P' : [(1, 'employs', 'subject')],
 'Any C,P where C is Company, P employed_by P' : [],
 'Any C where C is Company, C employs P' : [],
 }
 for rql, relations in queries.items():
-result = list(attr_desc_iterator(parse(rql).children[0]))
+result = list(attr_desc_iterator(parse(rql).children[0], 0, 0))
 self.assertEqual((rql, result), (rql, relations))
 def test_relations_description_indexed(self):
 """tests relations_description() function"""
 queries = {
 'Any C,U,P,L,M where C is Company, C employs P, U is CWUser, U login L, U mail M' :
 {0: [(2,'employs', 'subject')], 1: [(3,'login', 'subject'), (4,'mail', 'subject')]},
 }
 for rql, results in queries.items():
-for var_index, relations in results.items():
+for idx, relations in results.items():
-result = list(attr_desc_iterator(parse(rql).children[0], var_index))
+result = list(attr_desc_iterator(parse(rql).children[0], idx, idx))
 self.assertEqual(result, relations)
 class ResultSetTC(CubicWebTC):
 'Any U,L where U is CWUser, U login L',
 description=[['CWUser', 'String']] * 3)
 rs.req = self.request()
 rs.vreg = self.vreg
-rs2 = rs.sorted_rset(lambda e:e['login'])
+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['login'], reverse=True)
+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'])
 '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'])
-rsets = rs.split_rset(lambda e:e['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['login'], return_dict=True)
+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
 def test_get_entity_simple(self):
 self.request().create_entity('CWUser', login=u'adim', upassword='adim',
 surname=u'di mascio', firstname=u'adrien')
 e = self.execute('Any X,T WHERE X login "adim", X surname T').get_entity(0, 0)
-self.assertEqual(e['surname'], 'di mascio')
+self.assertEqual(e.cw_attr_cache['surname'], 'di mascio')
-self.assertRaises(KeyError, e.__getitem__, 'firstname')
+self.assertRaises(KeyError, e.cw_attr_cache.__getitem__, 'firstname')
-self.assertRaises(KeyError, e.__getitem__, 'creation_date')
+self.assertRaises(KeyError, e.cw_attr_cache.__getitem__, 'creation_date')
 self.assertEqual(pprelcachedict(e._cw_related_cache), [])
 e.complete()
-self.assertEqual(e['firstname'], 'adrien')
+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.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')
 e = rset.get_entity(0, 0)
 self.assertEqual(e.cw_row, 0)
 self.assertEqual(e.cw_col, 0)
-self.assertEqual(e['title'], 'zou')
+self.assertEqual(e.cw_attr_cache['title'], 'zou')
-self.assertRaises(KeyError, e.__getitem__, 'path')
+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['login'], 'anon')
+self.assertEqual(e.cw_attr_cache['login'], 'anon')
-self.assertRaises(KeyError, e.__getitem__, 'firstname')
+self.assertRaises(KeyError, e.cw_attr_cache.__getitem__, 'firstname')
 self.assertEqual(pprelcachedict(e._cw_related_cache),
 [])
 e.complete()
-self.assertEqual(e['firstname'], None)
+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)
 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['title'], 'zou')
+self.assertEqual(e.cw_attr_cache['title'], 'zou')
 self.assertEqual(pprelcachedict(e._cw_related_cache),
-[('created_by_subject', [5])])
+[('created_by_subject', [self.user().eid])])
 # first level of recursion
 u = e.created_by[0]
-self.assertEqual(u['login'], 'admin')
+self.assertEqual(u.cw_attr_cache['login'], 'admin')
-self.assertRaises(KeyError, u.__getitem__, 'firstname')
+self.assertRaises(KeyError, u.cw_attr_cache.__getitem__, 'firstname')
 # second level of recursion
 s = u.in_state[0]
-self.assertEqual(s['name'], 'activated')
+self.assertEqual(s.cw_attr_cache['name'], 'activated')
-self.assertRaises(KeyError, s.__getitem__, 'description')
+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]
 ('CWGroup', 'users'))
 for entity in rset.entities(): # test get_entity for each row actually
 etype, n = expected[entity.cw_row]
 self.assertEqual(entity.__regid__, etype)
 attr = etype == 'Bookmark' and 'title' or 'name'
-self.assertEqual(entity[attr], n)
+self.assertEqual(entity.cw_attr_cache[attr], n)
 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)
-def test_related_entity_union_subquery(self):
+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.__regid__, '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')
+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')
+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')
 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"')
 self.failUnless(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.failUnless(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')

branch	oldstable
changeset 7074	e4580e5f0703
parent 6915	99eb71b311e4
child 7298	a448e470c150