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.
server/test/unittest_ldapuser.py
branchstable
changeset 3855 dbd37c10f865
parent 3587 5b3725f315fc
child 3890 d7a270f50f54
child 4212 ab6573088b4a
equal deleted inserted replaced
3854:8633cd05b6b5 3855:dbd37c10f865 
     4 :copyright: 2001-2009 LOGILAB S.A. (Paris, FRANCE), license is LGPL v2.
 
     4 :copyright: 2001-2009 LOGILAB S.A. (Paris, FRANCE), license is LGPL v2.
 
     5 :contact: http://www.logilab.fr/ -- mailto:contact@logilab.fr
 
     5 :contact: http://www.logilab.fr/ -- mailto:contact@logilab.fr
 
     6 :license: GNU Lesser General Public License, v2.1 - http://www.gnu.org/licenses
 
     6 :license: GNU Lesser General Public License, v2.1 - http://www.gnu.org/licenses
 
     7 """
 
     7 """
 
     8 
     8 
       
     9 import socket
 
       
    10 
     9 from logilab.common.testlib import TestCase, unittest_main, mock_object
 
    11 from logilab.common.testlib import TestCase, unittest_main, mock_object
 
    10 from cubicweb.devtools import init_test_database, TestServerConfiguration
 
    12 from cubicweb.devtools import init_test_database, TestServerConfiguration
 
    11 from cubicweb.devtools.apptest import RepositoryBasedTC
 
    13 from cubicweb.devtools.apptest import RepositoryBasedTC
 
    12 from cubicweb.devtools.repotest import RQLGeneratorTC
 
    14 from cubicweb.devtools.repotest import RQLGeneratorTC
 
    13 
    15 
    14 from cubicweb.server.sources.ldapuser import *
 
    16 from cubicweb.server.sources.ldapuser import *
 
       
    17 
       
    18 if socket.gethostbyname('ldap').startswith('172'):
 
       
    19     SYT = 'syt'
 
       
    20     ADIM = 'adim'
 
       
    21 else:
 
       
    22     SYT = 'sthenault'
 
       
    23     ADIM = 'adimascio'
 
       
    24 
    15 
    25 
    16 def nopwd_authenticate(self, session, login, upassword):
 
    26 def nopwd_authenticate(self, session, login, upassword):
 
    17     """used to monkey patch the source to get successful authentication without
 
    27     """used to monkey patch the source to get successful authentication without
 
    18     upassword checking
 
    28     upassword checking
 
    19     """
 
    29     """
 
    71         source = self.repo.sources_by_uri['ldapuser']
 
    81         source = self.repo.sources_by_uri['ldapuser']
 
    72         source.synchronize()
 
    82         source.synchronize()
 
    73 
    83 
    74     def test_base(self):
 
    84     def test_base(self):
 
    75         # check a known one
 
    85         # check a known one
 
    76         e = self.execute('CWUser X WHERE X login "syt"').get_entity(0, 0)
 
    86         e = self.execute('CWUser X WHERE X login %(login)s', {'login': SYT}).get_entity(0, 0)
 
    77         self.assertEquals(e.login, 'syt')
 
    87         self.assertEquals(e.login, SYT)
 
    78         e.complete()
 
    88         e.complete()
 
    79         self.assertEquals(e.creation_date, None)
 
    89         self.assertEquals(e.creation_date, None)
 
    80         self.assertEquals(e.modification_date, None)
 
    90         self.assertEquals(e.modification_date, None)
 
    81         self.assertEquals(e.firstname, None)
 
    91         self.assertEquals(e.firstname, None)
 
    82         self.assertEquals(e.surname, None)
 
    92         self.assertEquals(e.surname, None)
 
    83         self.assertEquals(e.in_group[0].name, 'users')
 
    93         self.assertEquals(e.in_group[0].name, 'users')
 
    84         self.assertEquals(e.owned_by[0].login, 'syt')
 
    94         self.assertEquals(e.owned_by[0].login, SYT)
 
    85         self.assertEquals(e.created_by, ())
 
    95         self.assertEquals(e.created_by, ())
 
    86         self.assertEquals(e.primary_email[0].address, 'Sylvain Thenault')
 
    96         self.assertEquals(e.primary_email[0].address, 'Sylvain Thenault')
 
    87         # email content should be indexed on the user
 
    97         # email content should be indexed on the user
 
    88         rset = self.execute('CWUser X WHERE X has_text "thenault"')
 
    98         rset = self.execute('CWUser X WHERE X has_text "thenault"')
 
    89         self.assertEquals(rset.rows, [[e.eid]])
 
    99         self.assertEquals(rset.rows, [[e.eid]])
 
    90 
   100 
    91     def test_not(self):
 
   101     def test_not(self):
 
    92         eid = self.execute('CWUser X WHERE X login "syt"')[0][0]
 
   102         eid = self.execute('CWUser X WHERE X login %(login)s', {'login': SYT})[0][0]
 
    93         rset = self.execute('CWUser X WHERE NOT X eid %s' % eid)
 
   103         rset = self.execute('CWUser X WHERE NOT X eid %s' % eid)
 
    94         self.assert_(rset)
 
   104         self.assert_(rset)
 
    95         self.assert_(not eid in (r[0] for r in rset))
 
   105         self.assert_(not eid in (r[0] for r in rset))
 
    96 
   106 
    97     def test_multiple(self):
 
   107     def test_multiple(self):
 
    98         seid = self.execute('CWUser X WHERE X login "syt"')[0][0]
 
   108         seid = self.execute('CWUser X WHERE X login %(login)s', {'login': SYT})[0][0]
 
    99         aeid = self.execute('CWUser X WHERE X login "adim"')[0][0]
 
   109         aeid = self.execute('CWUser X WHERE X login %(login)s', {'login': ADIM})[0][0]
 
   100         rset = self.execute('CWUser X, Y WHERE X login "syt", Y login "adim"')
 
   110         rset = self.execute('CWUser X, Y WHERE X login %(syt)s, Y login %(adim)s',
 
       
   111                             {'syt': SYT, 'adim': ADIM})
 
   101         self.assertEquals(rset.rows, [[seid, aeid]])
 
   112         self.assertEquals(rset.rows, [[seid, aeid]])
 
   102         rset = self.execute('Any X,Y,L WHERE X login L, X login "syt", Y login "adim"')
 
   113         rset = self.execute('Any X,Y,L WHERE X login L, X login %(syt)s, Y login %(adim)s',
 
   103         self.assertEquals(rset.rows, [[seid, aeid, 'syt']])
 
   114                             {'syt': SYT, 'adim': ADIM})
 
       
   115         self.assertEquals(rset.rows, [[seid, aeid, SYT]])
 
   104 
   116 
   105     def test_in(self):
 
   117     def test_in(self):
 
   106         seid = self.execute('CWUser X WHERE X login "syt"')[0][0]
 
   118         seid = self.execute('CWUser X WHERE X login %(login)s', {'login': SYT})[0][0]
 
   107         aeid = self.execute('CWUser X WHERE X login "adim"')[0][0]
 
   119         aeid = self.execute('CWUser X WHERE X login %(login)s', {'login': ADIM})[0][0]
 
   108         rset = self.execute('Any X,L ORDERBY L WHERE X login IN("syt", "adim"), X login L')
 
   120         rset = self.execute('Any X,L ORDERBY L WHERE X login IN("%s", "%s"), X login L' % (SYT, ADIM))
 
   109         self.assertEquals(rset.rows, [[aeid, 'adim'], [seid, 'syt']])
 
   121         self.assertEquals(rset.rows, [[aeid, ADIM], [seid, SYT]])
 
   110 
   122 
   111     def test_relations(self):
 
   123     def test_relations(self):
 
   112         eid = self.execute('CWUser X WHERE X login "syt"')[0][0]
 
   124         eid = self.execute('CWUser X WHERE X login %(login)s', {'login': SYT})[0][0]
 
   113         rset = self.execute('Any X,E WHERE X is CWUser, X login L, X primary_email E')
 
   125         rset = self.execute('Any X,E WHERE X is CWUser, X login L, X primary_email E')
 
   114         self.assert_(eid in (r[0] for r in rset))
 
   126         self.assert_(eid in (r[0] for r in rset))
 
   115         rset = self.execute('Any X,L,E WHERE X is CWUser, X login L, X primary_email E')
 
   127         rset = self.execute('Any X,L,E WHERE X is CWUser, X login L, X primary_email E')
 
   116         self.assert_('syt' in (r[1] for r in rset))
 
   128         self.assert_(SYT in (r[1] for r in rset))
 
   117 
   129 
   118     def test_count(self):
 
   130     def test_count(self):
 
   119         nbusers = self.execute('Any COUNT(X) WHERE X is CWUser')[0][0]
 
   131         nbusers = self.execute('Any COUNT(X) WHERE X is CWUser')[0][0]
 
   120         # just check this is a possible number
 
   132         # just check this is a possible number
 
   121         self.assert_(nbusers > 1, nbusers)
 
   133         self.assert_(nbusers > 1, nbusers)
 
   122         self.assert_(nbusers < 30, nbusers)
 
   134         self.assert_(nbusers < 30, nbusers)
 
   123 
   135 
   124     def test_upper(self):
 
   136     def test_upper(self):
 
   125         eid = self.execute('CWUser X WHERE X login "syt"')[0][0]
 
   137         eid = self.execute('CWUser X WHERE X login %(login)s', {'login': SYT})[0][0]
 
   126         rset = self.execute('Any UPPER(L) WHERE X eid %s, X login L' % eid)
 
   138         rset = self.execute('Any UPPER(L) WHERE X eid %s, X login L' % eid)
 
   127         self.assertEquals(rset[0][0], 'SYT')
 
   139         self.assertEquals(rset[0][0], SYT.upper())
 
   128 
   140 
   129     def test_unknown_attr(self):
 
   141     def test_unknown_attr(self):
 
   130         eid = self.execute('CWUser X WHERE X login "syt"')[0][0]
 
   142         eid = self.execute('CWUser X WHERE X login %(login)s', {'login': SYT})[0][0]
 
   131         rset = self.execute('Any L,C,M WHERE X eid %s, X login L, '
 
   143         rset = self.execute('Any L,C,M WHERE X eid %s, X login L, '
 
   132                             'X creation_date C, X modification_date M' % eid)
 
   144                             'X creation_date C, X modification_date M' % eid)
 
   133         self.assertEquals(rset[0][0], 'syt')
 
   145         self.assertEquals(rset[0][0], SYT)
 
   134         self.assertEquals(rset[0][1], None)
 
   146         self.assertEquals(rset[0][1], None)
 
   135         self.assertEquals(rset[0][2], None)
 
   147         self.assertEquals(rset[0][2], None)
 
   136 
   148 
   137     def test_sort(self):
 
   149     def test_sort(self):
 
   138         logins = [l for l, in self.execute('Any L ORDERBY L WHERE X login L')]
 
   150         logins = [l for l, in self.execute('Any L ORDERBY L WHERE X login L')]
 
   141     def test_lower_sort(self):
 
   153     def test_lower_sort(self):
 
   142         logins = [l for l, in self.execute('Any L ORDERBY lower(L) WHERE X login L')]
 
   154         logins = [l for l, in self.execute('Any L ORDERBY lower(L) WHERE X login L')]
 
   143         self.assertEquals(logins, sorted(logins))
 
   155         self.assertEquals(logins, sorted(logins))
 
   144 
   156 
   145     def test_or(self):
 
   157     def test_or(self):
 
   146         rset = self.execute('DISTINCT Any X WHERE X login "syt" OR (X in_group G, G name "managers")')
 
   158         rset = self.execute('DISTINCT Any X WHERE X login %(login)s OR (X in_group G, G name "managers")',
 
       
   159                             {'login': SYT})
 
   147         self.assertEquals(len(rset), 2, rset.rows) # syt + admin
 
   160         self.assertEquals(len(rset), 2, rset.rows) # syt + admin
 
   148 
   161 
   149     def test_nonregr_set_owned_by(self):
 
   162     def test_nonregr_set_owned_by(self):
 
   150         # test that when a user coming from ldap is triggering a transition
 
   163         # test that when a user coming from ldap is triggering a transition
 
   151         # the related TrInfo has correct owner information
 
   164         # the related TrInfo has correct owner information
 
   152         self.execute('SET X in_group G WHERE X login "syt", G name "managers"')
 
   165         self.execute('SET X in_group G WHERE X login %(syt)s, G name "managers"', {'syt': SYT})
 
   153         self.commit()
 
   166         self.commit()
 
   154         syt = self.execute('CWUser X WHERE X login "syt"').get_entity(0, 0)
 
   167         syt = self.execute('CWUser X WHERE X login %(login)s', {'login': SYT}).get_entity(0, 0)
 
   155         self.assertEquals([g.name for g in syt.in_group], ['managers', 'users'])
 
   168         self.assertEquals([g.name for g in syt.in_group], ['managers', 'users'])
 
   156         self.patch_authenticate()
 
   169         self.patch_authenticate()
 
   157         cnx = self.login('syt', 'dummypassword')
 
   170         cnx = self.login(SYT, 'dummypassword')
 
   158         cu = cnx.cursor()
 
   171         cu = cnx.cursor()
 
   159         alf = cu.execute('Any X WHERE X login "alf"').get_entity(0, 0)
 
   172         adim = cu.execute('CWUser X WHERE X login %(login)s', {'login': ADIM}).get_entity(0, 0)
 
   160         alf.fire_transition('deactivate')
 
   173         adim.fire_transition('deactivate')
 
   161         try:
 
   174         try:
 
   162             cnx.commit()
 
   175             cnx.commit()
 
   163             alf = self.execute('CWUser X WHERE X login "alf"').get_entity(0, 0)
 
   176             adim.clear_all_caches()
 
   164             self.assertEquals(alf.in_state[0].name, 'deactivated')
 
   177             self.assertEquals(adim.in_state[0].name, 'deactivated')
 
   165             trinfo = alf.latest_trinfo()
 
   178             trinfo = adim.latest_trinfo()
 
   166             self.assertEquals(trinfo.owned_by[0].login, 'syt')
 
   179             self.assertEquals(trinfo.owned_by[0].login, SYT)
 
   167             # select from_state to skip the user's creation TrInfo
 
   180             # select from_state to skip the user's creation TrInfo
 
   168             rset = self.execute('Any U ORDERBY D DESC WHERE WF wf_info_for X,'
 
   181             rset = self.execute('Any U ORDERBY D DESC WHERE WF wf_info_for X,'
 
   169                                 'WF creation_date D, WF from_state FS,'
 
   182                                 'WF creation_date D, WF from_state FS,'
 
   170                                 'WF owned_by U?, X eid %(x)s',
 
   183                                 'WF owned_by U?, X eid %(x)s',
 
   171                                 {'x': alf.eid}, 'x')
 
   184                                 {'x': adim.eid}, 'x')
 
   172             self.assertEquals(rset.rows, [[syt.eid]])
 
   185             self.assertEquals(rset.rows, [[syt.eid]])
 
   173         finally:
 
   186         finally:
 
   174             # restore db state
 
   187             # restore db state
 
   175             self.restore_connection()
 
   188             self.restore_connection()
 
   176             alf = self.execute('Any X WHERE X login "alf"').get_entity(0, 0)
 
   189             adim = self.execute('CWUser X WHERE X login %(login)s', {'login': ADIM}).get_entity(0, 0)
 
   177             alf.fire_transition('activate')
 
   190             adim.fire_transition('activate')
 
   178             self.execute('DELETE X in_group G WHERE X login "syt", G name "managers"')
 
   191             self.execute('DELETE X in_group G WHERE X login %(syt)s, G name "managers"', {'syt': SYT})
 
   179 
   192 
   180     def test_same_column_names(self):
 
   193     def test_same_column_names(self):
 
   181         self.execute('Any X, Y WHERE X copain Y, X login "comme", Y login "cochon"')
 
   194         self.execute('Any X, Y WHERE X copain Y, X login "comme", Y login "cochon"')
 
   182 
   195 
   183     def test_multiple_entities_from_different_sources(self):
 
   196     def test_multiple_entities_from_different_sources(self):
 
   184         self.create_user('cochon')
 
   197         self.create_user('cochon')
 
   185         self.failUnless(self.execute('Any X,Y WHERE X login "syt", Y login "cochon"'))
 
   198         self.failUnless(self.execute('Any X,Y WHERE X login %(syt)s, Y login "cochon"', {'syt': SYT}))
 
   186 
   199 
   187     def test_exists1(self):
 
   200     def test_exists1(self):
 
   188         self.add_entity('CWGroup', name=u'bougloup1')
 
   201         self.add_entity('CWGroup', name=u'bougloup1')
 
   189         self.add_entity('CWGroup', name=u'bougloup2')
 
   202         self.add_entity('CWGroup', name=u'bougloup2')
 
   190         self.execute('SET U in_group G WHERE G name ~= "bougloup%", U login "admin"')
 
   203         self.execute('SET U in_group G WHERE G name ~= "bougloup%", U login "admin"')
 
   191         self.execute('SET U in_group G WHERE G name = "bougloup1", U login "syt"')
 
   204         self.execute('SET U in_group G WHERE G name = "bougloup1", U login %(syt)s', {'syt': SYT})
 
   192         rset = self.execute('Any L,SN ORDERBY L WHERE X in_state S, S name SN, X login L, EXISTS(X in_group G, G name ~= "bougloup%")')
 
   205         rset = self.execute('Any L,SN ORDERBY L WHERE X in_state S, S name SN, X login L, EXISTS(X in_group G, G name ~= "bougloup%")')
 
   193         self.assertEquals(rset.rows, [['admin', 'activated'], ['syt', 'activated']])
 
   206         self.assertEquals(rset.rows, [['admin', 'activated'], [SYT, 'activated']])
 
   194 
   207 
   195     def test_exists2(self):
 
   208     def test_exists2(self):
 
   196         self.create_user('comme')
 
   209         self.create_user('comme')
 
   197         self.create_user('cochon')
 
   210         self.create_user('cochon')
 
   198         self.execute('SET X copain Y WHERE X login "comme", Y login "cochon"')
 
   211         self.execute('SET X copain Y WHERE X login "comme", Y login "cochon"')
 
   202     def test_exists3(self):
 
   215     def test_exists3(self):
 
   203         self.create_user('comme')
 
   216         self.create_user('comme')
 
   204         self.create_user('cochon')
 
   217         self.create_user('cochon')
 
   205         self.execute('SET X copain Y WHERE X login "comme", Y login "cochon"')
 
   218         self.execute('SET X copain Y WHERE X login "comme", Y login "cochon"')
 
   206         self.failUnless(self.execute('Any X, Y WHERE X copain Y, X login "comme", Y login "cochon"'))
 
   219         self.failUnless(self.execute('Any X, Y WHERE X copain Y, X login "comme", Y login "cochon"'))
 
   207         self.execute('SET X copain Y WHERE X login "syt", Y login "cochon"')
 
   220         self.execute('SET X copain Y WHERE X login %(syt)s, Y login "cochon"', {'syt': SYT})
 
   208         self.failUnless(self.execute('Any X, Y WHERE X copain Y, X login "syt", Y login "cochon"'))
 
   221         self.failUnless(self.execute('Any X, Y WHERE X copain Y, X login %(syt)s, Y login "cochon"', {'syt': SYT}))
 
   209         rset = self.execute('Any GN,L WHERE X in_group G, X login L, G name GN, G name "managers" OR EXISTS(X copain T, T login in ("comme", "cochon"))')
 
   222         rset = self.execute('Any GN,L WHERE X in_group G, X login L, G name GN, G name "managers" OR EXISTS(X copain T, T login in ("comme", "cochon"))')
 
   210         self.assertEquals(sorted(rset.rows), [['managers', 'admin'], ['users', 'comme'], ['users', 'syt']])
 
   223         self.assertEquals(sorted(rset.rows), [['managers', 'admin'], ['users', 'comme'], ['users', SYT]])
 
   211 
   224 
   212     def test_exists4(self):
 
   225     def test_exists4(self):
 
   213         self.create_user('comme')
 
   226         self.create_user('comme')
 
   214         self.create_user('cochon', groups=('users', 'guests'))
 
   227         self.create_user('cochon', groups=('users', 'guests'))
 
   215         self.create_user('billy')
 
   228         self.create_user('billy')
 
   216         self.execute('SET X copain Y WHERE X login "comme", Y login "cochon"')
 
   229         self.execute('SET X copain Y WHERE X login "comme", Y login "cochon"')
 
   217         self.execute('SET X copain Y WHERE X login "cochon", Y login "cochon"')
 
   230         self.execute('SET X copain Y WHERE X login "cochon", Y login "cochon"')
 
   218         self.execute('SET X copain Y WHERE X login "comme", Y login "billy"')
 
   231         self.execute('SET X copain Y WHERE X login "comme", Y login "billy"')
 
   219         self.execute('SET X copain Y WHERE X login "syt", Y login "billy"')
 
   232         self.execute('SET X copain Y WHERE X login %(syt)s, Y login "billy"', {'syt': SYT})
 
   220         # search for group name, login where
 
   233         # search for group name, login where
 
   221         #   CWUser copain with "comme" or "cochon" AND same login as the copain
 
   234         #   CWUser copain with "comme" or "cochon" AND same login as the copain
 
   222         # OR
 
   235         # OR
 
   223         #   CWUser in_state activated AND not copain with billy
 
   236         #   CWUser in_state activated AND not copain with billy
 
   224         #
 
   237         #
 
   226         rset= self.execute('Any GN,L WHERE X in_group G, X login L, G name GN, '
 
   239         rset= self.execute('Any GN,L WHERE X in_group G, X login L, G name GN, '
 
   227                            'EXISTS(X copain T, T login L, T login in ("comme", "cochon")) OR '
 
   240                            'EXISTS(X copain T, T login L, T login in ("comme", "cochon")) OR '
 
   228                            'EXISTS(X in_state S, S name "activated", NOT X copain T2, T2 login "billy")')
 
   241                            'EXISTS(X in_state S, S name "activated", NOT X copain T2, T2 login "billy")')
 
   229         all = self.execute('Any GN, L WHERE X in_group G, X login L, G name GN')
 
   242         all = self.execute('Any GN, L WHERE X in_group G, X login L, G name GN')
 
   230         all.rows.remove(['users', 'comme'])
 
   243         all.rows.remove(['users', 'comme'])
 
   231         all.rows.remove(['users', 'syt'])
 
   244         all.rows.remove(['users', SYT])
 
   232         self.assertEquals(sorted(rset.rows), sorted(all.rows))
 
   245         self.assertEquals(sorted(rset.rows), sorted(all.rows))
 
   233 
   246 
   234     def test_exists5(self):
 
   247     def test_exists5(self):
 
   235         self.create_user('comme')
 
   248         self.create_user('comme')
 
   236         self.create_user('cochon', groups=('users', 'guests'))
 
   249         self.create_user('cochon', groups=('users', 'guests'))
 
   237         self.create_user('billy')
 
   250         self.create_user('billy')
 
   238         self.execute('SET X copain Y WHERE X login "comme", Y login "cochon"')
 
   251         self.execute('SET X copain Y WHERE X login "comme", Y login "cochon"')
 
   239         self.execute('SET X copain Y WHERE X login "cochon", Y login "cochon"')
 
   252         self.execute('SET X copain Y WHERE X login "cochon", Y login "cochon"')
 
   240         self.execute('SET X copain Y WHERE X login "comme", Y login "billy"')
 
   253         self.execute('SET X copain Y WHERE X login "comme", Y login "billy"')
 
   241         self.execute('SET X copain Y WHERE X login "syt", Y login "cochon"')
 
   254         self.execute('SET X copain Y WHERE X login %(syt)s, Y login "cochon"', {'syt': SYT})
 
   242         rset= self.execute('Any L WHERE X login L, '
 
   255         rset= self.execute('Any L WHERE X login L, '
 
   243                            'EXISTS(X copain T, T login in ("comme", "cochon")) AND '
 
   256                            'EXISTS(X copain T, T login in ("comme", "cochon")) AND '
 
   244                            'NOT EXISTS(X copain T2, T2 login "billy")')
 
   257                            'NOT EXISTS(X copain T2, T2 login "billy")')
 
   245         self.assertEquals(sorted(rset.rows), [['cochon'], ['syt']])
 
   258         self.assertEquals(sorted(rset.rows), [['cochon'], [SYT]])
 
   246         rset= self.execute('Any GN,L WHERE X in_group G, X login L, G name GN, '
 
   259         rset= self.execute('Any GN,L WHERE X in_group G, X login L, G name GN, '
 
   247                            'EXISTS(X copain T, T login in ("comme", "cochon")) AND '
 
   260                            'EXISTS(X copain T, T login in ("comme", "cochon")) AND '
 
   248                            'NOT EXISTS(X copain T2, T2 login "billy")')
 
   261                            'NOT EXISTS(X copain T2, T2 login "billy")')
 
   249         self.assertEquals(sorted(rset.rows), [['guests', 'cochon'],
 
   262         self.assertEquals(sorted(rset.rows), [['guests', 'cochon'],
 
   250                                               ['users', 'cochon'],
 
   263                                               ['users', 'cochon'],
 
   251                                               ['users', 'syt']])
 
   264                                               ['users', SYT]])
 
   252 
   265 
   253     def test_cd_restriction(self):
 
   266     def test_cd_restriction(self):
 
   254         rset = self.execute('CWUser X WHERE X creation_date > "2009-02-01"')
 
   267         rset = self.execute('CWUser X WHERE X creation_date > "2009-02-01"')
 
   255         self.assertEquals(len(rset), 2) # admin/anon but no ldap user since it doesn't support creation_date
 
   268         self.assertEquals(len(rset), 2) # admin/anon but no ldap user since it doesn't support creation_date
 
   256 
   269 
   266         cnx = self.login('iaminguestsgrouponly')
 
   279         cnx = self.login('iaminguestsgrouponly')
 
   267         return cnx.cursor()
 
   280         return cnx.cursor()
 
   268 
   281 
   269     def test_security1(self):
 
   282     def test_security1(self):
 
   270         cu = self._init_security_test()
 
   283         cu = self._init_security_test()
 
   271         rset = cu.execute('Any X WHERE X login "syt"')
 
   284         rset = cu.execute('CWUser X WHERE X login %(login)s', {'login': SYT})
 
   272         self.assertEquals(rset.rows, [])
 
   285         self.assertEquals(rset.rows, [])
 
   273         rset = cu.execute('Any X WHERE X login "iaminguestsgrouponly"')
 
   286         rset = cu.execute('Any X WHERE X login "iaminguestsgrouponly"')
 
   274         self.assertEquals(len(rset.rows), 1)
 
   287         self.assertEquals(len(rset.rows), 1)
 
   275 
   288 
   276     def test_security2(self):
 
   289     def test_security2(self):
 
   277         cu = self._init_security_test()
 
   290         cu = self._init_security_test()
 
   278         rset = cu.execute('Any X WHERE X has_text "syt"')
 
   291         rset = cu.execute('Any X WHERE X has_text %(syt)s', {'syt': SYT})
 
   279         self.assertEquals(rset.rows, [])
 
   292         self.assertEquals(rset.rows, [])
 
   280         rset = cu.execute('Any X WHERE X has_text "iaminguestsgrouponly"')
 
   293         rset = cu.execute('Any X WHERE X has_text "iaminguestsgrouponly"')
 
   281         self.assertEquals(len(rset.rows), 1)
 
   294         self.assertEquals(len(rset.rows), 1)
 
   282 
   295 
   283     def test_security3(self):
 
   296     def test_security3(self):
 
   284         cu = self._init_security_test()
 
   297         cu = self._init_security_test()
 
   285         rset = cu.execute('Any F WHERE X has_text "syt", X firstname F')
 
   298         rset = cu.execute('Any F WHERE X has_text %(syt)s, X firstname F', {'syt': SYT})
 
   286         self.assertEquals(rset.rows, [])
 
   299         self.assertEquals(rset.rows, [])
 
   287         rset = cu.execute('Any F WHERE X has_text "iaminguestsgrouponly", X firstname F')
 
   300         rset = cu.execute('Any F WHERE X has_text "iaminguestsgrouponly", X firstname F')
 
   288         self.assertEquals(rset.rows, [[None]])
 
   301         self.assertEquals(rset.rows, [[None]])
 
   289 
   302 
   290     def test_nonregr1(self):
 
   303     def test_nonregr1(self):
cubicweb