cubicweb: comparison server/test/unittest

equal deleted inserted replaced

-:bdc3dc94d744
+:470d8e828fda
 def test_not_relation_read_security(self):
 cnx = self.login('iaminusersgrouponly')
 self.hijack_source_execute()
 self.execute('Any U WHERE NOT A todo_by U, A is Affaire')
-self.assertEquals(self.query[0][1].as_string(),
+self.assertEqual(self.query[0][1].as_string(),
 'Any U WHERE NOT EXISTS(A todo_by U), A is Affaire')
 self.execute('Any U WHERE NOT EXISTS(A todo_by U), A is Affaire')
-self.assertEquals(self.query[0][1].as_string(),
+self.assertEqual(self.query[0][1].as_string(),
 'Any U WHERE NOT EXISTS(A todo_by U), A is Affaire')
 class SecurityTC(BaseSecurityTC):
 def setUp(self):
 def test_insert_security(self):
 cnx = self.login('anon')
 cu = cnx.cursor()
 cu.execute("INSERT Personne X: X nom 'bidule'")
 self.assertRaises(Unauthorized, cnx.commit)
-self.assertEquals(cu.execute('Personne X').rowcount, 1)
+self.assertEqual(cu.execute('Personne X').rowcount, 1)
 def test_insert_rql_permission(self):
 # test user can only add une affaire related to a societe he owns
 cnx = self.login('iaminusersgrouponly')
 cu = cnx.cursor()
 cu.execute("INSERT Affaire X: X sujet 'cool'")
 self.assertRaises(Unauthorized, cnx.commit)
 # test nothing has actually been inserted
 self.restore_connection()
-self.assertEquals(self.execute('Affaire X').rowcount, 1)
+self.assertEqual(self.execute('Affaire X').rowcount, 1)
 cnx = self.login('iaminusersgrouponly')
 cu = cnx.cursor()
 cu.execute("INSERT Affaire X: X sujet 'cool'")
 cu.execute("INSERT Societe X: X nom 'chouette'")
 cu.execute("SET A concerne S WHERE A sujet 'cool', S nom 'chouette'")
 cu = cnx.cursor()
 # local security check
 cu.execute( "SET X nom 'bidulechouette' WHERE X is Personne")
 self.assertRaises(Unauthorized, cnx.commit)
 self.restore_connection()
-self.assertEquals(self.execute('Personne X WHERE X nom "bidulechouette"').rowcount, 0)
+self.assertEqual(self.execute('Personne X WHERE X nom "bidulechouette"').rowcount, 0)
 def test_update_security_2(self):
 cnx = self.login('anon')
 cu = cnx.cursor()
 self.repo.schema['Personne'].set_action_permissions('read', ('users', 'managers'))
 self.repo.schema['Personne'].set_action_permissions('add', ('guests', 'users', 'managers'))
 self.assertRaises(Unauthorized, cu.execute, "SET X nom 'bidulechouette' WHERE X is Personne")
 #self.assertRaises(Unauthorized, cnx.commit)
 # test nothing has actually been inserted
 self.restore_connection()
-self.assertEquals(self.execute('Personne X WHERE X nom "bidulechouette"').rowcount, 0)
+self.assertEqual(self.execute('Personne X WHERE X nom "bidulechouette"').rowcount, 0)
 def test_update_security_3(self):
 cnx = self.login('iaminusersgrouponly')
 cu = cnx.cursor()
 cu.execute("INSERT Personne X: X nom 'biduuule'")
 # should raise Unauthorized since user don't own S
 # though this won't actually do anything since the selection query won't return anything
 cnx.commit()
 # to actually get Unauthorized exception, try to insert a relation were we can read both entities
 rset = cu.execute('Personne P')
-self.assertEquals(len(rset), 1)
+self.assertEqual(len(rset), 1)
 ent = rset.get_entity(0, 0)
 session.set_pool() # necessary
 self.assertRaises(Unauthorized, ent.cw_check_perm, 'update')
 self.assertRaises(Unauthorized,
 cu.execute, "SET P travaille S WHERE P is Personne, S is Societe")
 # test nothing has actually been inserted:
-self.assertEquals(cu.execute('Any P,S WHERE P travaille S,P is Personne, S is Societe').rowcount, 0)
+self.assertEqual(cu.execute('Any P,S WHERE P travaille S,P is Personne, S is Societe').rowcount, 0)
 cu.execute("INSERT Societe X: X nom 'chouette'")
 cu.execute("SET A concerne S WHERE A is Affaire, S nom 'chouette'")
 cnx.commit()
 def test_delete_relation_rql_permission(self):
 eid = self.execute("INSERT Affaire X: X sujet 'cool'")[0][0]
 self.commit()
 cnx = self.login('iaminusersgrouponly')
 cu = cnx.cursor()
 rset = cu.execute('Affaire X')
-self.assertEquals(rset.rows, [])
+self.assertEqual(rset.rows, [])
 self.assertRaises(Unauthorized, cu.execute, 'Any X WHERE X eid %(x)s', {'x': eid})
 # cache test
 self.assertRaises(Unauthorized, cu.execute, 'Any X WHERE X eid %(x)s', {'x': eid})
 aff2 = cu.execute("INSERT Affaire X: X sujet 'cool'")[0][0]
 soc1 = cu.execute("INSERT Societe X: X nom 'chouette'")[0][0]
 cu.execute("SET A concerne S WHERE A is Affaire, S is Societe")
 cnx.commit()
 rset = cu.execute('Any X WHERE X eid %(x)s', {'x': aff2})
-self.assertEquals(rset.rows, [[aff2]])
+self.assertEqual(rset.rows, [[aff2]])
 # more cache test w/ NOT eid
 rset = cu.execute('Affaire X WHERE NOT X eid %(x)s', {'x': eid})
-self.assertEquals(rset.rows, [[aff2]])
+self.assertEqual(rset.rows, [[aff2]])
 rset = cu.execute('Affaire X WHERE NOT X eid %(x)s', {'x': aff2})
-self.assertEquals(rset.rows, [])
+self.assertEqual(rset.rows, [])
 # test can't update an attribute of an entity that can't be readen
 self.assertRaises(Unauthorized, cu.execute, 'SET X sujet "hacked" WHERE X eid %(x)s', {'x': eid})
 def test_entity_created_in_transaction(self):
 aff2 = cu.execute("INSERT Affaire X: X sujet 'cool'")[0][0]
 # entity created in transaction are readable *by eid*
 self.failUnless(cu.execute('Any X WHERE X eid %(x)s', {'x':aff2}))
 # XXX would be nice if it worked
 rset = cu.execute("Affaire X WHERE X sujet 'cool'")
-self.assertEquals(len(rset), 0)
+self.assertEqual(len(rset), 0)
 finally:
 affschema.set_action_permissions('read', origperms)
 cnx.close()
 def test_read_erqlexpr_has_text1(self):
 cnx.commit()
 self.assertRaises(Unauthorized, cu.execute, 'Any X WHERE X eid %(x)s', {'x':aff1})
 self.failUnless(cu.execute('Any X WHERE X eid %(x)s', {'x':aff2}))
 self.failUnless(cu.execute('Any X WHERE X eid %(x)s', {'x':card1}))
 rset = cu.execute("Any X WHERE X has_text 'cool'")
-self.assertEquals(sorted(eid for eid, in rset.rows),
+self.assertEqual(sorted(eid for eid, in rset.rows),
 [card1, aff2])
 def test_read_erqlexpr_has_text2(self):
 self.execute("INSERT Personne X: X nom 'bidule'")
 self.execute("INSERT Societe X: X nom 'bidule'")
 self.commit()
 self.schema['Personne'].set_action_permissions('read', ('managers',))
 cnx = self.login('iaminusersgrouponly')
 cu = cnx.cursor()
 rset = cu.execute('Any N WHERE N has_text "bidule"')
-self.assertEquals(len(rset.rows), 1, rset.rows)
+self.assertEqual(len(rset.rows), 1, rset.rows)
 rset = cu.execute('Any N WITH N BEING (Any N WHERE N has_text "bidule")')
-self.assertEquals(len(rset.rows), 1, rset.rows)
+self.assertEqual(len(rset.rows), 1, rset.rows)
 def test_read_erqlexpr_optional_rel(self):
 self.execute("INSERT Personne X: X nom 'bidule'")
 self.execute("INSERT Societe X: X nom 'bidule'")
 self.commit()
 self.schema['Personne'].set_action_permissions('read', ('managers',))
 cnx = self.login('anon')
 cu = cnx.cursor()
 rset = cu.execute('Any N,U WHERE N has_text "bidule", N owned_by U?')
-self.assertEquals(len(rset.rows), 1, rset.rows)
+self.assertEqual(len(rset.rows), 1, rset.rows)
 def test_read_erqlexpr_aggregat(self):
 self.execute("INSERT Affaire X: X sujet 'cool'")[0][0]
 self.commit()
 cnx = self.login('iaminusersgrouponly')
 cu = cnx.cursor()
 rset = cu.execute('Any COUNT(X) WHERE X is Affaire')
-self.assertEquals(rset.rows, [[0]])
+self.assertEqual(rset.rows, [[0]])
 aff2 = cu.execute("INSERT Affaire X: X sujet 'cool'")[0][0]
 soc1 = cu.execute("INSERT Societe X: X nom 'chouette'")[0][0]
 cu.execute("SET A concerne S WHERE A is Affaire, S is Societe")
 cnx.commit()
 rset = cu.execute('Any COUNT(X) WHERE X is Affaire')
-self.assertEquals(rset.rows, [[1]])
+self.assertEqual(rset.rows, [[1]])
 rset = cu.execute('Any ETN, COUNT(X) GROUPBY ETN WHERE X is ET, ET name ETN')
 values = dict(rset)
-self.assertEquals(values['Affaire'], 1)
+self.assertEqual(values['Affaire'], 1)
-self.assertEquals(values['Societe'], 2)
+self.assertEqual(values['Societe'], 2)
 rset = cu.execute('Any ETN, COUNT(X) GROUPBY ETN WHERE X is ET, ET name ETN WITH X BEING ((Affaire X) UNION (Societe X))')
-self.assertEquals(len(rset), 2)
+self.assertEqual(len(rset), 2)
 values = dict(rset)
-self.assertEquals(values['Affaire'], 1)
+self.assertEqual(values['Affaire'], 1)
-self.assertEquals(values['Societe'], 2)
+self.assertEqual(values['Societe'], 2)
 def test_attribute_security(self):
 # only managers should be able to edit the 'test' attribute of Personne entities
 eid = self.execute("INSERT Personne X: X nom 'bidule', X web 'http://www.debian.org', X test TRUE")[0][0]
 self.assertRaises(Unauthorized, cnx.commit)
 note2 = cu.execute("INSERT Note X: X para 'bidule'").get_entity(0, 0)
 cnx.commit()
 note2.cw_adapt_to('IWorkflowable').fire_transition('markasdone')
 cnx.commit()
-self.assertEquals(len(cu.execute('Any X WHERE X in_state S, S name "todo", X eid %(x)s', {'x': note2.eid})),
+self.assertEqual(len(cu.execute('Any X WHERE X in_state S, S name "todo", X eid %(x)s', {'x': note2.eid})),
 0)
 cu.execute("SET X para 'chouette' WHERE X eid %(x)s", {'x': note2.eid})
 self.assertRaises(Unauthorized, cnx.commit)
 note2.cw_adapt_to('IWorkflowable').fire_transition('redoit')
 cnx.commit()
 cnx = self.login('anon')
 cu = cnx.cursor()
 rset = cu.execute('CWUser X')
 self.failUnless(rset)
 x = rset.get_entity(0, 0)
-self.assertEquals(x.login, None)
+self.assertEqual(x.login, None)
 self.failUnless(x.creation_date)
 x = rset.get_entity(1, 0)
 x.complete()
-self.assertEquals(x.login, None)
+self.assertEqual(x.login, None)
 self.failUnless(x.creation_date)
 cnx.rollback()
 class BaseSchemaSecurityTC(BaseSecurityTC):
 """tests related to the base schema permission configuration"""
 cnx.commit()
 self.restore_connection()
 affaire = self.execute('Any X WHERE X ref "ARCT01"').get_entity(0, 0)
 affaire.cw_adapt_to('IWorkflowable').fire_transition('abort')
 self.commit()
-self.assertEquals(len(self.execute('TrInfo X WHERE X wf_info_for A, A ref "ARCT01"')),
+self.assertEqual(len(self.execute('TrInfo X WHERE X wf_info_for A, A ref "ARCT01"')),
 1)
-self.assertEquals(len(self.execute('TrInfo X WHERE X wf_info_for A, A ref "ARCT01",'
+self.assertEqual(len(self.execute('TrInfo X WHERE X wf_info_for A, A ref "ARCT01",'
 'X owned_by U, U login "admin"')),
 1) # TrInfo at the above state change
 cnx = self.login('iaminusersgrouponly')
 cu = cnx.cursor()
 cu.execute('DELETE Affaire X WHERE X ref "ARCT01"')
 cnx = self.login('anon')
 anon = cnx.user(self.session)
 cu = cnx.cursor()
 # anonymous user can only read itself
 rset = cu.execute('Any L WHERE X owned_by U, U login L')
-self.assertEquals(rset.rows, [['anon']])
+self.assertEqual(rset.rows, [['anon']])
 rset = cu.execute('CWUser X')
-self.assertEquals(rset.rows, [[anon.eid]])
+self.assertEqual(rset.rows, [[anon.eid]])
 # anonymous user can read groups (necessary to check allowed transitions for instance)
 self.assert_(cu.execute('CWGroup X'))
 # should only be able to read the anonymous user, not another one
 origuser = self.adminsession.user
 self.assertRaises(Unauthorized,
 #self.assertRaises(Unauthorized,
 #                  cu.execute, 'SET X login "toto" WHERE X eid %(x)s',
 #                  {'x': self.user.eid})
 rset = cu.execute('CWUser X WHERE X eid %(x)s', {'x': anon.eid})
-self.assertEquals(rset.rows, [[anon.eid]])
+self.assertEqual(rset.rows, [[anon.eid]])
 # but can't modify it
 cu.execute('SET X login "toto" WHERE X eid %(x)s', {'x': anon.eid})
 self.assertRaises(Unauthorized, cnx.commit)
 def test_in_group_relation(self):
 beid2 = self.execute('INSERT Bookmark B: B path "?vid=index", B title "index", B bookmarked_by U WHERE U login "anon"')[0][0]
 self.commit()
 cnx = self.login('anon')
 cu = cnx.cursor()
 anoneid = self.session.user.eid
-self.assertEquals(cu.execute('Any T,P ORDERBY lower(T) WHERE B is Bookmark,B title T,B path P,'
+self.assertEqual(cu.execute('Any T,P ORDERBY lower(T) WHERE B is Bookmark,B title T,B path P,'
 'B bookmarked_by U, U eid %s' % anoneid).rows,
 [['index', '?vid=index']])
-self.assertEquals(cu.execute('Any T,P ORDERBY lower(T) WHERE B is Bookmark,B title T,B path P,'
+self.assertEqual(cu.execute('Any T,P ORDERBY lower(T) WHERE B is Bookmark,B title T,B path P,'
 'B bookmarked_by U, U eid %(x)s', {'x': anoneid}).rows,
 [['index', '?vid=index']])
 # can read others bookmarks as well
-self.assertEquals(cu.execute('Any B where B is Bookmark, NOT B bookmarked_by U').rows,
+self.assertEqual(cu.execute('Any B where B is Bookmark, NOT B bookmarked_by U').rows,
 [[beid1]])
 self.assertRaises(Unauthorized, cu.execute,'DELETE B bookmarked_by U')
 self.assertRaises(Unauthorized,
 cu.execute, 'SET B bookmarked_by U WHERE U eid %(x)s, B eid %(b)s',
 {'x': anoneid, 'b': beid1})
 def test_ambigous_ordered(self):
 cnx = self.login('anon')
 cu = cnx.cursor()
 names = [t for t, in cu.execute('Any N ORDERBY lower(N) WHERE X name N')]
-self.assertEquals(names, sorted(names, key=lambda x: x.lower()))
+self.assertEqual(names, sorted(names, key=lambda x: x.lower()))
 def test_in_state_without_update_perm(self):
 """check a user change in_state without having update permission on the
 subject
 """
 self.execute('SET TI comment %(c)s WHERE TI wf_info_for X, X ref "ARCT01"',
 {'c': u'bouh!'})
 self.commit()
 aff.cw_clear_relation_cache('wf_info_for', 'object')
 trinfo = iworkflowable.latest_trinfo()
-self.assertEquals(trinfo.comment, 'bouh!')
+self.assertEqual(trinfo.comment, 'bouh!')
 # but not from_state/to_state
 aff.cw_clear_relation_cache('wf_info_for', role='object')
 self.assertRaises(Unauthorized,
 self.execute, 'SET TI from_state S WHERE TI eid %(ti)s, S name "ben non"',
 {'ti': trinfo.eid})

branch	stable
changeset 6340	470d8e828fda
parent 5890	141b935a38fc
child 6410	2e7a7b0829ed