cubicweb: comparison cubicweb/test/unittest

equal deleted inserted replaced

-:e034454af0d5
+:1c0dce14c3b5
 """TestCase for cubicweb.rset.attr_desc_iterator"""
 def test_relations_description(self):
 """tests relations_description() function"""
 queries = {
-'Any U,L,M where U is CWUser, U login L, U mail M': [(1, 'login', 'subject'), (2, 'mail', 'subject')],
+'Any U,L,M where U is CWUser, U login L, U mail M': [
-'Any U,L,M where U is CWUser, L is Foo, U mail M': [(2, 'mail', 'subject')],
+(1, 'login', 'subject'), (2, 'mail', 'subject')],
-'Any C,P where C is Company, C employs P': [(1, 'employs', 'subject')],
+'Any U,L,M where U is CWUser, L is Foo, U mail M': [
+(2, 'mail', 'subject')],
+'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], 0, 0))
 result = list(attr_desc_iterator(parse(rql).children[0], idx, idx))
 self.assertEqual(result, relations)
 def test_subquery_callfunc(self):
 rql = ('Any A,B,C,COUNT(D) GROUPBY A,B,C WITH A,B,C,D BEING '
-'(Any YEAR(CD), MONTH(CD), S, X WHERE X is CWUser, X creation_date CD, X in_state S)')
+'(Any YEAR(CD), MONTH(CD), S, X WHERE X is CWUser, '
+'X creation_date CD, X in_state S)')
 rqlst = parse(rql)
 select, col = rqlst.locate_subquery(2, 'CWUser', None)
 result = list(attr_desc_iterator(select, col, 2))
 self.assertEqual(result, [])
 def test_subquery_callfunc_2(self):
-rql = ('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)')
+rql = ('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)')
 rqlst = parse(rql)
 select, col = rqlst.locate_subquery(0, 'CWUser', None)
 result = list(attr_desc_iterator(select, col, 0))
 self.assertEqual(result, [(1, 'in_state', 'subject')])
 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'),
+# self.compare_urls(req.build_url('view', _restpath='/task/title/go'),
-#                  '%stask/title/go' % baseurl)
+#                   '%stask/title/go' % baseurl)
 # empty _restpath should not crash
 self.compare_urls(req.build_url('view', _restpath=''), baseurl)
 def test_build(self):
 """test basic build of a ResultSet"""
-rs = ResultSet([1,2,3], 'CWGroup X', description=['CWGroup', 'CWGroup', 'CWGroup'])
+rs = ResultSet([1, 2, 3], 'CWGroup X',
+description=['CWGroup', 'CWGroup', 'CWGroup'])
 self.assertEqual(rs.rowcount, 3)
-self.assertEqual(rs.rows, [1,2,3])
+self.assertEqual(rs.rows, [1, 2, 3])
 self.assertEqual(rs.description, ['CWGroup', 'CWGroup', 'CWGroup'])
 def test_limit(self):
 rs = ResultSet([[12000, 'adim'], [13000, 'syt'], [14000, 'nico']],
 'Any U,L where U is CWUser, U login L',
 description=[['CWUser', 'String']] * 3)
 def test_limit_2(self):
 with self.admin_access.web_request() as req:
 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)
+e1 = rs.get_entity(9, 0)  # noqa
 # 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)
 'Any U,L where U is CWUser, U login L',
 description=[['CWUser', 'String']] * 3)
 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)
 rs = ResultSet([[12, 'adim'], [13, 'syt'], [14, 'nico']],
 'Any U,L where U is CWUser, U login L',
 description=[['CWUser', 'String']] * 3)
 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(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)
 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'])
+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)
+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'])
 self.assertEqual([login for _, login in rs], ['adim', 'syt', 'nico'])
 def test_split(self):
 rs = ResultSet([[12000, 'adim', u'Adim chez les pinguins'],
 [12000, 'adim', u'Jardiner facile'],
-[13000, 'syt',  u'Le carrelage en 42 leçons'],
+[13000, 'syt', u'Le carrelage en 42 leçons'],
 [14000, 'nico', u'La tarte tatin en 15 minutes'],
 [14000, 'nico', u"L'épluchage du castor commun"]],
-'Any U, L, T WHERE U is CWUser, U login L,'\
+('Any U, L, T WHERE U is CWUser, U login L,'
-'D created_by U, D title T',
+'D created_by U, D title T'),
 description=[['CWUser', 'String', 'String']] * 5)
 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'])
+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[0]], ['adim', 'adim'])
-self.assertEqual([login for _, login,_ in rsets[1]], ['syt'])
+self.assertEqual([login for _, login, _ in rsets[1]], ['syt'])
-self.assertEqual([login for _, login,_ in rsets[2]], ['nico', 'nico'])
+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'])
+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)
+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['nico']], ['nico', 'nico'])
-self.assertEqual([login for _, login,_ in rsets['adim']], ['adim', 'adim'])
+self.assertEqual([login for _, login, _ in rsets['adim']], ['adim', 'adim'])
-self.assertEqual([login for _, login,_ in rsets['syt']], ['syt'])
+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'])
+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",])
+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",])
+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"""
 rqlst1 = self.rset.syntax_tree()
 rqlst2 = self.rset.syntax_tree()
 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),
+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.assertEqual(pprelcachedict(e._cw_related_cache), [])
-[])
 self.assertRaises(NotAnEntity, rset.get_entity, 0, 2)
 self.assertRaises(NotAnEntity, rset.get_entity, 0, 3)
 def test_get_entity_relation_cache_compt(self):
 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):
 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
 rset.get_entity(0, 1)
 self.assertTrue(mail.cw_relation_cached('primary_email', 'object'))
 u = cnx.user
 self.assertTrue(u.cw_relation_cached('primary_email', 'subject'))
 def test_get_entity_cache_with_left_outer_join(self):
 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):
 with self.admin_access.web_request() as req:
-e = req.create_entity('Bookmark', title=u'manger', path=u'path')
+req.create_entity('Bookmark', title=u'manger', path=u'path')
 req.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
+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):
 with self.admin_access.web_request() as req:
-req.create_entity('CWUser', login=u'cdevienne',
+req.create_entity('CWUser',
-upassword=u'cdevienne',
+login=u'cdevienne',
-surname=u'de Vienne',
+upassword=u'cdevienne',
-firstname=u'Christophe')
+surname=u'de Vienne',
+firstname=u'Christophe')
 e = req.execute('Any X WHERE X login "cdevienne"').one()
 self.assertEqual(e.surname, u'de Vienne')
 e = req.execute(
 with self.assertRaises(MultipleResultsError):
 req.execute('Any X WHERE X is CWUser').one()
 def test_related_entity_optional(self):
 with self.admin_access.web_request() as req:
-e = req.create_entity('Bookmark', title=u'aaaa', path=u'path')
+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):
 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)
 def test_related_entity_union_subquery_2(self):
 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):
 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):
 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):
 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):
 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):
 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',]))
+set(['CWUser']))
 self.assertEqual(set(e.e_schema.type for e in rset.entities(1)),
-set(['CWGroup',]))
+set(['CWGroup']))
 def test_iter_rows_with_entities(self):
 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[0].login, out[1])
-self.assertEqual( out[2].name, out[3] )
+self.assertEqual(out[2].name, out[3])
 def test_printable_rql(self):
 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):
 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'})
+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):
 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_possible_actions_cache(self):
 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')
 rset.possible_actions(argument='Value')
 self.assertRaises(AssertionError, rset.possible_actions, argument='OtherValue')
 self.assertRaises(AssertionError, rset.possible_actions, other_argument='Value')
 def test_count_users_by_date(self):
 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')
+rset = req.execute('Any D, COUNT(U) GROUPBY D '
-self.assertEqual(rset.related_entity(0,0), (None, None))
+'WHERE U is CWUser, U creation_date D')
+self.assertEqual(rset.related_entity(0, 0), (None, None))
 def test_str(self):
 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), string_types)
 self.assertEqual(len(str(rset).splitlines()), 1)
 def test_slice(self):
 rs = ResultSet([[12000, 'adim', u'Adim chez les pinguins'],
 [12000, 'adim', u'Jardiner facile'],
-[13000, 'syt',  u'Le carrelage en 42 leçons'],
+[13000, 'syt', u'Le carrelage en 42 leçons'],
 [14000, 'nico', u'La tarte tatin en 15 minutes'],
 [14000, 'nico', u"L'épluchage du castor commun"]],
-'Any U, L, T WHERE U is CWUser, U login L,'\
+('Any U, L, T WHERE U is CWUser, U login L,'
-'D created_by U, D title T',
+'D created_by U, D title T'),
 description=[['CWUser', 'String', 'String']] * 5)
 self.assertEqual(rs[1::2],
 [[12000, 'adim', u'Jardiner facile'],
 [14000, 'nico', u'La tarte tatin en 15 minutes']])
 def test_nonregr_symmetric_relation(self):
 # see https://www.cubicweb.org/ticket/4739253
 with self.admin_access.client_cnx() as cnx:
 p1 = cnx.create_entity('Personne', nom=u'sylvain')
 cnx.create_entity('Personne', nom=u'denis', connait=p1)
 cnx.commit()
 rset = cnx.execute('Any X,Y WHERE X connait Y')
-rset.get_entity(0, 1) # used to raise KeyError
+rset.get_entity(0, 1)  # used to raise KeyError
 if __name__ == '__main__':
 unittest_main()

branch	3.26
changeset 12420	1c0dce14c3b5
parent 12063	4bcb58aa103a
child 12421	e460eac6e648