ldap/python: Fix last tests.
[samba.git] / source4 / lib / ldb / tests / python / ldap.py
1 #!/usr/bin/python
2 # -*- coding: utf-8 -*-
3 # This is a port of the original in testprogs/ejs/ldap.js
4
5 import getopt
6 import optparse
7 import sys
8
9 # Add path to the library for in-tree use
10 sys.path.append("scripting/python")
11 import samba.getopt as options
12
13 from auth import system_session
14 from ldb import SCOPE_SUBTREE, SCOPE_ONELEVEL, SCOPE_BASE, LdbError
15 from samba import Ldb
16 import param
17
18 parser = optparse.OptionParser("ldap [options] <host>")
19 parser.add_option_group(options.SambaOptions(parser))
20 parser.add_option_group(options.VersionOptions(parser))
21 # use command line creds if available
22 credopts = options.CredentialsOptions(parser)
23 parser.add_option_group(credopts)
24 creds = credopts.get_credentials()
25 opts, args = parser.parse_args()
26
27 if len(args) < 1:
28     parser.print_usage()
29     sys.exit(1)
30
31 host = args[0]
32
33 lp = param.LoadParm()
34 if opts.configfile:
35     lp.load(opts.configfile)
36
37 def delete_force(ldb, dn):
38     try:
39         ldb.delete(dn)
40     except LdbError, (num, _): 
41         if num != 32: # LDAP_NO_SUCH_OBJECT
42             assert False
43
44 def assertEquals(a1, a2):
45     assert a1 == a2, "Expected %r == %r" % (a1, a2)
46
47 def basic_tests(ldb, gc_ldb, base_dn, configuration_dn, schema_dn):
48     print "Running basic tests"
49
50     delete_force(ldb, "cn=ldaptestuser,cn=users," + base_dn)
51     delete_force(ldb, "cn=ldaptestgroup,cn=users," + base_dn)
52
53     print "Testing group add with invalid member"
54     try:
55         ldb.add({
56         "dn": "cn=ldaptestgroup,cn=uSers," + base_dn,
57         "objectclass": "group",
58         "member": "cn=ldaptestuser,cn=useRs," + base_dn})
59     except LdbError, (num, _): 
60         if num != 32: # LDAP_NO_SUCH_OBJECT
61             assert False
62     else:
63         assert False
64
65     print "Testing user add"
66     try:
67         ldb.add({
68         "dn": "cn=ldaptestuser,cn=uSers," + base_dn,
69         "objectclass": ["user", "person"],
70         "cN": "LDAPtestUSER",
71         "givenname": "ldap",
72         "sn": "testy"})
73     except LdbError:
74         ldb.delete("cn=ldaptestuser,cn=users," + base_dn)
75         ldb.add({
76             "dn": "cn=ldaptestuser,cn=uSers," + base_dn,
77             "objectclass": ["user", "person"],
78             "cN": "LDAPtestUSER",
79             "givenname": "ldap",
80             "sn": "testy"})
81
82     ldb.add({
83         "dn": "cn=ldaptestgroup,cn=uSers," + base_dn,
84         "objectclass": "group",
85         "member": "cn=ldaptestuser,cn=useRs," + base_dn})
86
87     try:
88         ldb.add({
89         "dn": "cn=ldaptestcomputer,cn=computers," + base_dn,
90         "objectclass": "computer",
91         "cN": "LDAPtestCOMPUTER"})
92     except LdbError:
93         ldb.delete("cn=ldaptestcomputer,cn=computers," + base_dn)
94         ldb.add({
95             "dn": "cn=ldaptestcomputer,cn=computers," + base_dn,
96             "objectClass": "computer",
97             "cn": "LDAPtestCOMPUTER"})
98
99     try:
100         ldb.add({"dn": "cn=ldaptest2computer,cn=computers," + base_dn,
101         "objectClass": "computer",
102         "cn": "LDAPtest2COMPUTER",
103         "userAccountControl": "4096",
104         "displayname": "ldap testy"})
105     except LdbError:
106         ldb.delete("cn=ldaptest2computer,cn=computers," + base_dn)
107         ldb.add({
108             "dn": "cn=ldaptest2computer,cn=computers," + base_dn,
109             "objectClass": "computer",
110             "cn": "LDAPtest2COMPUTER",
111             "userAccountControl": "4096",
112             "displayname": "ldap testy"})
113
114     print "Testing attribute or value exists behaviour"
115     try:
116         ldb.modify_ldif("""
117 dn: cn=ldaptest2computer,cn=computers,""" + base_dn + """
118 changetype: modify
119 replace: servicePrincipalName
120 servicePrincipalName: host/ldaptest2computer
121 servicePrincipalName: host/ldaptest2computer
122 servicePrincipalName: cifs/ldaptest2computer
123 """)
124     except LdbError, (num, msg):
125         #LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS
126         assert num == 20, "Expected error LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS, got : %s" % msg
127
128         ldb.modify_ldif("""
129 dn: cn=ldaptest2computer,cn=computers,""" + base_dn + """
130 changetype: modify
131 replace: servicePrincipalName
132 servicePrincipalName: host/ldaptest2computer
133 servicePrincipalName: cifs/ldaptest2computer
134 """)
135         try:
136             ldb.modify_ldif("""
137 dn: cn=ldaptest2computer,cn=computers,""" + base_dn + """
138 changetype: modify
139 add: servicePrincipalName
140 servicePrincipalName: host/ldaptest2computer
141 """)
142         except LdbError, (num, msg):
143             assert num == 20, "Expected error LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS, got :" + msg
144         
145         print "Testing ranged results"
146         ldb.modify_ldif("""
147 dn: cn=ldaptest2computer,cn=computers,""" + base_dn + """
148 changetype: modify
149 replace: servicePrincipalName
150 """)
151         
152         ldb.modify_ldif("""
153 dn: cn=ldaptest2computer,cn=computers,""" + base_dn + """
154 changetype: modify
155 add: servicePrincipalName
156 servicePrincipalName: host/ldaptest2computer0
157 servicePrincipalName: host/ldaptest2computer1
158 servicePrincipalName: host/ldaptest2computer2
159 servicePrincipalName: host/ldaptest2computer3
160 servicePrincipalName: host/ldaptest2computer4
161 servicePrincipalName: host/ldaptest2computer5
162 servicePrincipalName: host/ldaptest2computer6
163 servicePrincipalName: host/ldaptest2computer7
164 servicePrincipalName: host/ldaptest2computer8
165 servicePrincipalName: host/ldaptest2computer9
166 servicePrincipalName: host/ldaptest2computer10
167 servicePrincipalName: host/ldaptest2computer11
168 servicePrincipalName: host/ldaptest2computer12
169 servicePrincipalName: host/ldaptest2computer13
170 servicePrincipalName: host/ldaptest2computer14
171 servicePrincipalName: host/ldaptest2computer15
172 servicePrincipalName: host/ldaptest2computer16
173 servicePrincipalName: host/ldaptest2computer17
174 servicePrincipalName: host/ldaptest2computer18
175 servicePrincipalName: host/ldaptest2computer19
176 servicePrincipalName: host/ldaptest2computer20
177 servicePrincipalName: host/ldaptest2computer21
178 servicePrincipalName: host/ldaptest2computer22
179 servicePrincipalName: host/ldaptest2computer23
180 servicePrincipalName: host/ldaptest2computer24
181 servicePrincipalName: host/ldaptest2computer25
182 servicePrincipalName: host/ldaptest2computer26
183 servicePrincipalName: host/ldaptest2computer27
184 servicePrincipalName: host/ldaptest2computer28
185 servicePrincipalName: host/ldaptest2computer29
186 """)
187
188         res = ldb.search(base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, 
189                          attrs=["servicePrincipalName;range=0-*"])
190         assert len(res) == 1, "Could not find (cn=ldaptest2computer)"
191         #print len(res[0]["servicePrincipalName;range=0-*"])
192         assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30)
193
194         res = ldb.search(base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-19"])
195         assert len(res) == 1, "Could not find (cn=ldaptest2computer)"
196 #        print res[0]["servicePrincipalName;range=0-19"].length
197         assertEquals(len(res[0]["servicePrincipalName;range=0-19"]), 20)
198
199         
200         res = ldb.search(base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-30"])
201         assert len(res) == 1, "Could not find (cn=ldaptest2computer)"
202         assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30)
203
204         res = ldb.search(base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-40"])
205         assert len(res) == 1, "Could not find (cn=ldaptest2computer)"
206         assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30)
207
208         res = ldb.search(base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=30-40"])
209         assert len(res) == 1, "Could not find (cn=ldaptest2computer)"
210         assertEquals(len(res[0]["servicePrincipalName;range=30-*"]), 0)
211
212         
213         res = ldb.search(base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=10-40"])
214         assert len(res) == 1, "Could not find (cn=ldaptest2computer)"
215         assertEquals(len(res[0]["servicePrincipalName;range=10-*"]), 20)
216 #        pos_11 = res[0]["servicePrincipalName;range=10-*"][18]
217
218         res = ldb.search(base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=11-40"])
219         assert len(res) == 1, "Could not find (cn=ldaptest2computer)"
220         assertEquals(len(res[0]["servicePrincipalName;range=11-*"]), 19)
221 #        print res[0]["servicePrincipalName;range=11-*"][18]
222 #        print pos_11
223 #        assertEquals((res[0]["servicePrincipalName;range=11-*"][18]), pos_11)
224
225         res = ldb.search(base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=11-15"])
226         assert len(res) == 1, "Could not find (cn=ldaptest2computer)"
227         assertEquals(len(res[0]["servicePrincipalName;range=11-15"]), 5)
228 #        assertEquals(res[0]["servicePrincipalName;range=11-15"][4], pos_11)
229
230         res = ldb.search(base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName"])
231         assert len(res) == 1, "Could not find (cn=ldaptest2computer)"
232 #        print res[0]["servicePrincipalName"][18]
233 #        print pos_11
234         assertEquals(len(res[0]["servicePrincipalName"]), 30)
235 #        assertEquals(res[0]["servicePrincipalName"][18], pos_11)
236
237     try:
238         ldb.add({
239         "dn": "cn=ldaptestuser2,cn=useRs," + base_dn,
240         "objectClass": ["person", "user"],
241         "cn": "LDAPtestUSER2",
242         "givenname": "testy",
243         "sn": "ldap user2"})
244     except LdbError:
245         ldb.delete("cn=ldaptestuser2,cn=users," + base_dn)
246         ldb.add({
247                 "dn": "cn=ldaptestuser2,cn=useRs," + base_dn,
248                 "objectClass": ["person", "user"],
249                 "cn": "LDAPtestUSER2",
250                 "givenname": "testy",
251                 "sn": "ldap user2"})
252
253     print "Testing Ambigious Name Resolution"
254 #   Testing ldb.search for (&(anr=ldap testy)(objectClass=user))
255     res = ldb.search(expression="(&(anr=ldap testy)(objectClass=user))")
256     assert len(res) == 3, "Could not find (&(anr=ldap testy)(objectClass=user))"
257
258 #   Testing ldb.search for (&(anr=testy ldap)(objectClass=user))
259     res = ldb.search(expression="(&(anr=testy ldap)(objectClass=user))")
260     assert len(res) == 2, "Found only %d for (&(anr=testy ldap)(objectClass=user))" % len(res)
261
262 #   Testing ldb.search for (&(anr=ldap)(objectClass=user))
263     res = ldb.search(expression="(&(anr=ldap)(objectClass=user))")
264     assert len(res) == 4, "Found only %d for (&(anr=ldap)(objectClass=user))" % len(res)
265
266 #   Testing ldb.search for (&(anr==ldap)(objectClass=user))
267     res = ldb.search(expression="(&(anr==ldap)(objectClass=user))")
268     assert len(res) == 1, "Could not find (&(anr==ldap)(objectClass=user)). Found only %d for (&(anr=ldap)(objectClass=user))" % len(res)
269
270     assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + base_dn))
271     assertEquals(res[0]["cn"][0], "ldaptestuser")
272     assertEquals(res[0]["name"], "ldaptestuser")
273
274 #   Testing ldb.search for (&(anr=testy)(objectClass=user))
275     res = ldb.search(expression="(&(anr=testy)(objectClass=user))")
276     assert len(res) == 2, "Found only %d for (&(anr=testy)(objectClass=user))" % len(res)
277
278 #   Testing ldb.search for (&(anr=ldap testy)(objectClass=user))
279     res = ldb.search(expression="(&(anr=testy ldap)(objectClass=user))")
280     assert len(res) == 2, "Found only %d for (&(anr=ldap testy)(objectClass=user))" % len(res)
281
282 #   Testing ldb.search for (&(anr==ldap testy)(objectClass=user))
283     res = ldb.search(expression="(&(anr==testy ldap)(objectClass=user))")
284     assert len(res) == 1, "Found only %d for (&(anr==ldap testy)(objectClass=user))" % len(res)
285
286     assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + base_dn))
287     assertEquals(res[0]["cn"][0], "ldaptestuser")
288     assertEquals(res[0]["name"][0], "ldaptestuser")
289
290 # Testing ldb.search for (&(anr==testy ldap)(objectClass=user))
291     res = ldb.search(expression="(&(anr==testy ldap)(objectClass=user))")
292     assert len(res) == 1, "Could not find (&(anr==testy ldap)(objectClass=user))"
293
294     assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + base_dn))
295     assertEquals(res[0]["cn"][0], "ldaptestuser")
296     assertEquals(res[0]["name"][0], "ldaptestuser")
297
298     # Testing ldb.search for (&(anr=testy ldap user)(objectClass=user))
299     res = ldb.search(expression="(&(anr=testy ldap user)(objectClass=user))")
300     assert len(res) == 1, "Could not find (&(anr=testy ldap user)(objectClass=user))"
301
302     assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + base_dn))
303     assertEquals(res[0]["cn"], "ldaptestuser2")
304     assertEquals(res[0]["name"], "ldaptestuser2")
305
306     # Testing ldb.search for (&(anr==testy ldap user2)(objectClass=user))
307     res = ldb.search(expression="(&(anr==testy ldap user2)(objectClass=user))")
308     assert len(res) == 1, "Could not find (&(anr==testy ldap user2)(objectClass=user))"
309
310     assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + base_dn))
311     assertEquals(res[0]["cn"], "ldaptestuser2")
312     assertEquals(res[0]["name"], "ldaptestuser2")
313
314     # Testing ldb.search for (&(anr==ldap user2)(objectClass=user))
315     res = ldb.search(expression="(&(anr==ldap user2)(objectClass=user))")
316     assert len(res) == 1, "Could not find (&(anr==ldap user2)(objectClass=user))"
317
318     assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + base_dn))
319     assertEquals(res[0]["cn"], "ldaptestuser2")
320     assertEquals(res[0]["name"], "ldaptestuser2")
321
322     # Testing ldb.search for (&(anr==not ldap user2)(objectClass=user))
323     res = ldb.search(expression="(&(anr==not ldap user2)(objectClass=user))")
324     assert len(res) == 0, "Must not find (&(anr==not ldap user2)(objectClass=user))"
325
326     # Testing ldb.search for (&(anr=not ldap user2)(objectClass=user))
327     res = ldb.search(expression="(&(anr=not ldap user2)(objectClass=user))")
328     assert len(res) == 0, "Must not find (&(anr=not ldap user2)(objectClass=user))"
329
330     print "Testing Group Modifies"
331     ldb.modify_ldif("""
332 dn: cn=ldaptestgroup,cn=users,""" + base_dn + """
333 changetype: modify
334 add: member
335 member: cn=ldaptestuser2,cn=users,""" + base_dn + """
336 member: cn=ldaptestcomputer,cn=computers,""" + base_dn + """
337 """)
338
339     delete_force(ldb, "cn=ldaptestuser3,cn=users," + base_dn)
340
341     print "Testing adding non-existent user to a group"
342     try:
343         ldb.modify_ldif("""
344 dn: cn=ldaptestgroup,cn=users,""" + base_dn + """
345 changetype: modify
346 add: member
347 member: cn=ldaptestuser3,cn=users,""" + base_dn + """
348 """)
349     except LdbError, (num, _):
350         assert num == 32
351     else:
352         assert False
353
354     print "Testing Renames"
355
356     ldb.rename("cn=ldaptestuser2,cn=users," + base_dn, "cn=ldaptestuser3,cn=users," + base_dn)
357
358     ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser3,cn=users," + base_dn)
359
360     ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestUSER3,cn=users," + base_dn)
361
362     print "Testing ldb.search for (&(cn=ldaptestuser3)(objectClass=user))"
363     res = ldb.search(expression="(&(cn=ldaptestuser3)(objectClass=user))")
364     assert len(res) == 1, "Could not find (&(cn=ldaptestuser3)(objectClass=user))"
365
366     assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + base_dn))
367     assertEquals(res[0]["cn"], "ldaptestUSER3")
368     assertEquals(res[0]["name"], "ldaptestUSER3")
369
370 # This is a Samba special, and does not exist in real AD
371 #    print "Testing ldb.search for (dn=CN=ldaptestUSER3,CN=Users," + base_dn + ")"
372 #    res = ldb.search("(dn=CN=ldaptestUSER3,CN=Users," + base_dn + ")")
373 #    if (res.error != 0 || len(res) != 1) {
374 #        print "Could not find (dn=CN=ldaptestUSER3,CN=Users," + base_dn + ")"
375 #        assertEquals(len(res), 1)
376 #    }
377 #    assertEquals(res[0].dn, ("CN=ldaptestUSER3,CN=Users," + base_dn))
378 #    assertEquals(res[0].cn, "ldaptestUSER3")
379 #    assertEquals(res[0].name, "ldaptestUSER3")
380
381     print "Testing ldb.search for (distinguishedName=CN=ldaptestUSER3,CN=Users," + base_dn + ")"
382     res = ldb.search(expression="(distinguishedName=CN=ldaptestUSER3,CN=Users," + base_dn + ")")
383     assert len(res) == 1, "Could not find (dn=CN=ldaptestUSER3,CN=Users," + base_dn + ")"
384     assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + base_dn))
385     assertEquals(res[0]["cn"], "ldaptestUSER3")
386     assertEquals(res[0]["name"], "ldaptestUSER3")
387
388     # ensure we cannot add it again
389     try:
390         ldb.add({"dn": "cn=ldaptestuser3,cn=userS," + base_dn,
391                   "objectClass": ["person", "user"],
392                   "cn": "LDAPtestUSER3"})
393     except LdbError, (num, _):
394         assert num == 68 #LDB_ERR_ENTRY_ALREADY_EXISTS
395     else:
396         assert False
397
398     # rename back
399     ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser2,cn=users," + base_dn)
400
401     # ensure we cannnot rename it twice
402     try:
403         ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser2,cn=users," + base_dn)
404     except LdbError, (num, _): 
405         assert num == 32 # LDAP_NO_SUCH_OBJECT
406     else:
407         assert False
408
409     # ensure can now use that name
410     ldb.add({"dn": "cn=ldaptestuser3,cn=users," + base_dn,
411                   "objectClass": ["person", "user"],
412                   "cn": "LDAPtestUSER3"})
413     
414     # ensure we now cannnot rename
415     try:
416         ldb.rename("cn=ldaptestuser2,cn=users," + base_dn, "cn=ldaptestuser3,cn=users," + base_dn)
417     except LdbError, (num, _):
418         assert num == 68 #LDB_ERR_ENTRY_ALREADY_EXISTS
419     else:
420         assert False
421     try:
422         ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser3,cn=configuration," + base_dn)
423     except LdbError, (num, _):
424         assert num in (71, 64)
425     else:
426         assert False
427
428     ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser5,cn=users," + base_dn)
429
430     ldb.delete("cn=ldaptestuser5,cn=users," + base_dn)
431
432     delete_force(ldb, "cn=ldaptestgroup2,cn=users," + base_dn)
433
434     ldb.rename("cn=ldaptestgroup,cn=users," + base_dn, "cn=ldaptestgroup2,cn=users," + base_dn)
435
436     print "Testing subtree Renames"
437
438     ldb.add({"dn": "cn=ldaptestcontainer," + base_dn, 
439              "objectClass": "container"})
440     
441     try:
442         ldb.add({"dn": "CN=ldaptestuser4,CN=ldaptestcontainer," + base_dn, 
443              "objectClass": ["person", "user"],
444              "cn": "LDAPtestUSER4"})
445     except LdbError:
446         ldb.delete("cn=ldaptestuser4,cn=ldaptestcontainer," + base_dn)
447         ldb.add({"dn": "CN=ldaptestuser4,CN=ldaptestcontainer," + base_dn,
448                       "objectClass": ["person", "user"],
449                       "cn": "LDAPtestUSER4"})
450
451     ldb.modify_ldif("""
452 dn: cn=ldaptestgroup2,cn=users,""" + base_dn + """
453 changetype: modify
454 add: member
455 member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """
456 """)
457     
458     print "Testing ldb.rename of cn=ldaptestcontainer," + base_dn + " to cn=ldaptestcontainer2," + base_dn
459     ldb.rename("CN=ldaptestcontainer," + base_dn, "CN=ldaptestcontainer2," + base_dn)
460
461     print "Testing ldb.search for (&(cn=ldaptestuser4)(objectClass=user))"
462     res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))")
463     assert len(res) == 1, "Could not find (&(cn=ldaptestuser4)(objectClass=user))"
464
465     print "Testing subtree ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + base_dn
466     try:
467         ldb.search("cn=ldaptestcontainer," + base_dn, 
468                 expression="(&(cn=ldaptestuser4)(objectClass=user))", 
469                 scope=SCOPE_SUBTREE)
470     except LdbError, (num, _):
471         assert num == 32
472     else:
473         assert False
474
475     print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + base_dn
476     try:
477         res = ldb.search("cn=ldaptestcontainer," + base_dn, expression="(&(cn=ldaptestuser4)(objectClass=user))", scope=SCOPE_ONELEVEL)
478     except LdbError, (num, _):
479         assert num == 32
480     else:
481         assert False
482
483     print "Testing ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in renamed container"
484     res = ldb.search("cn=ldaptestcontainer2," + base_dn, expression="(&(cn=ldaptestuser4)(objectClass=user))", scope=SCOPE_SUBTREE)
485     assert len(res) == 1, "Could not find (&(cn=ldaptestuser4)(objectClass=user)) under cn=ldaptestcontainer2," + base_dn
486
487     assertEquals(str(res[0].dn), ("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn))
488     assertEquals(res[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + base_dn).upper())
489
490     print "Testing ldb.search for (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn + ")(objectclass=group)) to check subtree renames and linked attributes"
491     res = ldb.search(base_dn, expression="(&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn + ")(objectclass=group))", scope=SCOPE_SUBTREE)
492     assert len(res) == 1, "Could not find (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn + ")(objectclass=group)), perhaps linked attributes are not conistant with subtree renames?"
493
494     print "Testing ldb.rename (into itself) of cn=ldaptestcontainer2," + base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer2," + base_dn
495     try:
496         ldb.rename("cn=ldaptestcontainer2," + base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer2," + base_dn)
497     except LdbError, (num, _):
498         assert num == 53 # LDAP_UNWILLING_TO_PERFORM
499     else:
500         assert False
501
502     print "Testing ldb.rename (into non-existent container) of cn=ldaptestcontainer2," + base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer3," + base_dn
503     try:
504         ldb.rename("cn=ldaptestcontainer2," + base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer3," + base_dn)
505     except LdbError, (num, _):
506         assert num in (53, 80)
507     else:
508         assert False
509
510     print "Testing delete (should fail, not a leaf node) of renamed cn=ldaptestcontainer2," + base_dn
511     try:
512         ldb.delete("cn=ldaptestcontainer2," + base_dn)
513     except LdbError, (num, _):
514         assert num == 66
515     else:
516         assert False
517
518     print "Testing base ldb.search for CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn
519     res = ldb.search(expression="(objectclass=*)", base=("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn), scope=SCOPE_BASE)
520     assert len(res) == 1
521     res = ldb.search(expression="(cn=ldaptestuser40)", base=("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn), scope=SCOPE_BASE)
522     assert len(res) == 0
523
524     print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in cn=ldaptestcontainer2," + base_dn
525     res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))", base="cn=ldaptestcontainer2," + base_dn, scope=SCOPE_ONELEVEL)
526     # FIXME: assert len(res) == 0
527
528     print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in cn=ldaptestcontainer2," + base_dn
529     res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))", base="cn=ldaptestcontainer2," + base_dn, scope=SCOPE_SUBTREE)
530     #FIXME: assert len(res) == 0
531
532     print "Testing delete of subtree renamed "+("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn)
533     ldb.delete(("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn))
534     print "Testing delete of renamed cn=ldaptestcontainer2," + base_dn
535     ldb.delete("cn=ldaptestcontainer2," + base_dn)
536     
537     try:
538         ldb.add({"dn": "cn=ldaptestutf8user èùéìòà ,cn=users," + base_dn, "objectClass": "user"})
539     except LdbError, (num, _):
540         ldb.delete("cn=ldaptestutf8user èùéìòà ,cn=users," + base_dn)
541         ldb.add({"dn": "cn=ldaptestutf8user èùéìòà ,cn=users," + base_dn, "objectClass": "user"})
542
543     try:
544         ldb.add({"dn": "cn=ldaptestutf8user2  èùéìòà ,cn=users," + base_dn, "objectClass": "user"})
545     except LdbError, (num, _):
546         ldb.delete("cn=ldaptestutf8user2  èùéìòà ,cn=users," + base_dn)
547         ldb.add({"dn": "cn=ldaptestutf8user2  èùéìòà ,cn=users," + base_dn,
548                   "objectClass": "user"})
549
550     print "Testing ldb.search for (&(cn=ldaptestuser)(objectClass=user))"
551     res = ldb.search(expression="(&(cn=ldaptestuser)(objectClass=user))")
552     assert len(res) == 1, "Could not find (&(cn=ldaptestuser)(objectClass=user))"
553
554     assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + base_dn))
555     assertEquals(res[0]["cn"], "ldaptestuser")
556     assertEquals(res[0]["name"], "ldaptestuser")
557     assertEquals(res[0]["objectClass"], ["top", "person", "organizationalPerson", "user"])
558     assert("objectGUID" in res[0])
559     assert("whenCreated" in res[0])
560     assertEquals(res[0]["objectCategory"], ("CN=Person,CN=Schema,CN=Configuration," + base_dn))
561     assertEquals(int(res[0]["sAMAccountType"][0]), 805306368)
562 #    assertEquals(res[0].userAccountControl, 546)
563     assertEquals(res[0]["memberOf"][0], ("CN=ldaptestgroup2,CN=Users," + base_dn))
564     assertEquals(len(res[0]["memberOf"]), 1)
565  
566     print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + base_dn + "))"
567     res2 = ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + base_dn + "))")
568     assert len(res2) == 1, "Could not find (&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + base_dn + "))"
569
570     assertEquals(res[0].dn, res2[0].dn)
571
572     print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon))"
573     res3 = ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=PerSon))")
574     assert len(res3) == 1, "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)): matched " + len(res3)
575
576     assertEquals(res[0].dn, res3[0].dn)
577
578     if gc_ldb is not None:
579         print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog"
580         res3gc = gc_ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=PerSon))")
581         assert len(res3gc) == 1
582     
583         assertEquals(res[0].dn, res3gc[0].dn)
584
585     print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon)) in with 'phantom root' control"
586     
587     res3control = gc_ldb.search(base_dn, expression="(&(cn=ldaptestuser)(objectCategory=PerSon))", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:2"])
588     assert len(res3control) == 1, "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog"
589     
590     assertEquals(res[0].dn, res3control[0].dn)
591
592     ldb.delete(res[0].dn)
593
594     print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectClass=user))"
595     res = ldb.search(expression="(&(cn=ldaptestcomputer)(objectClass=user))")
596     assert len(res) == 1, "Could not find (&(cn=ldaptestuser)(objectClass=user))"
597
598     assertEquals(str(res[0].dn), ("CN=ldaptestcomputer,CN=Computers," + base_dn))
599     assertEquals(res[0]["cn"], "ldaptestcomputer")
600     assertEquals(res[0]["name"], "ldaptestcomputer")
601     assertEquals(res[0]["objectClass"], ["top", "person", "organizationalPerson", "user", "computer"])
602     assert("objectGUID" in res[0])
603     assert("whenCreated" in res[0])
604     assertEquals(res[0]["objectCategory"], ("CN=Computer,CN=Schema,CN=Configuration," + base_dn))
605     assertEquals(int(res[0]["primaryGroupID"][0]), 513)
606 #    assertEquals(res[0].sAMAccountType, 805306368)
607 #    assertEquals(res[0].userAccountControl, 546)
608     assertEquals(res[0]["memberOf"][0], "CN=ldaptestgroup2,CN=Users," + base_dn)
609     assertEquals(len(res[0]["memberOf"]), 1)
610
611     print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + "))"
612     res2 = ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + "))")
613     assert len(res2) == 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + "))"
614
615     assertEquals(res[0].dn, res2[0].dn)
616
617     if gc_ldb is not None:
618         print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + ")) in Global Catlog"
619         res2gc = gc_ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + "))")
620         assert len(res2gc) == 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + ")) in Global Catlog"
621
622         assertEquals(res[0].dn, res2gc[0].dn)
623
624     print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER))"
625     res3 = ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=compuTER))")
626     assert len(res3) == 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER))"
627
628     assertEquals(res[0].dn, res3[0].dn)
629
630     if gc_ldb is not None:
631         print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog"
632         res3gc = gc_ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=compuTER))")
633         assert len(res3gc) == 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog"
634
635         assertEquals(res[0].dn, res3gc[0].dn)
636
637     print "Testing ldb.search for (&(cn=ldaptestcomp*r)(objectCategory=compuTER))"
638     res4 = ldb.search(expression="(&(cn=ldaptestcomp*r)(objectCategory=compuTER))")
639     assert len(res4) == 1, "Could not find (&(cn=ldaptestcomp*r)(objectCategory=compuTER))"
640
641     assertEquals(res[0].dn, res4[0].dn)
642
643     print "Testing ldb.search for (&(cn=ldaptestcomput*)(objectCategory=compuTER))"
644     res5 = ldb.search(expression="(&(cn=ldaptestcomput*)(objectCategory=compuTER))")
645     assert len(res5) == 1, "Could not find (&(cn=ldaptestcomput*)(objectCategory=compuTER))"
646
647     assertEquals(res[0].dn, res5[0].dn)
648
649     print "Testing ldb.search for (&(cn=*daptestcomputer)(objectCategory=compuTER))"
650     res6 = ldb.search(expression="(&(cn=*daptestcomputer)(objectCategory=compuTER))")
651     assert len(res6) == 1, "Could not find (&(cn=*daptestcomputer)(objectCategory=compuTER))"
652
653     assertEquals(res[0].dn, res6[0].dn)
654
655     ldb.delete(res[0].dn)
656
657     print "Testing ldb.search for (&(cn=ldaptest2computer)(objectClass=user))"
658     res = ldb.search(expression="(&(cn=ldaptest2computer)(objectClass=user))")
659     assert len(res) == 1, "Could not find (&(cn=ldaptest2computer)(objectClass=user))"
660
661     assertEquals(res[0].dn, ("CN=ldaptest2computer,CN=Computers," + base_dn))
662     assertEquals(res[0]["cn"], "ldaptest2computer")
663     assertEquals(res[0]["name"], "ldaptest2computer")
664     assertEquals(res[0]["objectClass"], ["top", "person", "organizationalPerson", "user", "computer"])
665     assert("objectGUID" in res[0])
666     assert("whenCreated" in res[0])
667     assertEquals(res[0]["objectCategory"][0], "CN=Computer,CN=Schema,CN=Configuration," + base_dn)
668     assertEquals(int(res[0]["sAMAccountType"][0]), 805306369)
669 #    assertEquals(res[0].userAccountControl, 4098)
670
671     ldb.delete(res[0].dn)
672
673     attrs = ["cn", "name", "objectClass", "objectGUID", "whenCreated", "nTSecurityDescriptor", "memberOf"]
674     print "Testing ldb.search for (&(cn=ldaptestUSer2)(objectClass=user))"
675     res = ldb.search(base_dn, expression="(&(cn=ldaptestUSer2)(objectClass=user))", scope=SCOPE_SUBTREE, attrs=attrs)
676     assert len(res) == 1, "Could not find (&(cn=ldaptestUSer2)(objectClass=user))"
677
678     assertEquals(res[0].dn, ("CN=ldaptestuser2,CN=Users," + base_dn))
679     assertEquals(res[0]["cn"], "ldaptestuser2")
680     assertEquals(res[0]["name"], "ldaptestuser2")
681     assertEquals(res[0]["objectClass"], ["top", "person", "organizationalPerson", "user"])
682     assert("objectGUID" in res[0])
683     assert("whenCreated" in res[0])
684     assert("nTSecurityDescriptor" in res[0])
685     assertEquals(res[0]["memberOf"][0], ("CN=ldaptestgroup2,CN=Users," + base_dn))
686
687     attrs = ["cn", "name", "objectClass", "objectGUID", "whenCreated", "nTSecurityDescriptor", "member"]
688     print "Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group))"
689     res = ldb.search(base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs)
690     assert len(res) == 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))"
691
692     assertEquals(res[0].dn, ("CN=ldaptestgroup2,CN=Users," + base_dn))
693     assertEquals(res[0]["cn"], "ldaptestgroup2")
694     assertEquals(res[0]["name"], "ldaptestgroup2")
695     assertEquals(res[0]["objectClass"], ["top", "group"])
696     assert("objectGuid" not in res[0])
697     assert("whenCreated" in res[0])
698     assert("nTSecurityDescriptor" in res[0])
699     assertEquals(res[0]["member"], ["CN=ldaptestuser2,CN=Users," + base_dn])
700
701     ldb.modify_ldif("""
702 dn: cn=ldaptestgroup2,cn=users,""" + base_dn + """
703 changetype: modify
704 replace: member
705 member: CN=ldaptestuser2,CN=Users,""" + base_dn + """
706 member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """
707 """)
708     
709     print "Testing Linked attribute behaviours"
710     ldb.modify_ldif("""
711 dn: cn=ldaptestgroup2,cn=users,""" + base_dn + """
712 changetype: modify
713 delete: member
714 """)
715
716     ldb.modify_ldif("""
717 dn: cn=ldaptestgroup2,cn=users,""" + base_dn + """
718 changetype: modify
719 add: member
720 member: CN=ldaptestuser2,CN=Users,""" + base_dn + """
721 member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """
722 """)
723     
724     ldb.modify_ldif("""
725 dn: cn=ldaptestgroup2,cn=users,""" + base_dn + """
726 changetype: modify
727 replace: member
728 """)
729     
730     ldb.modify_ldif("""
731 dn: cn=ldaptestgroup2,cn=users,""" + base_dn + """
732 changetype: modify
733 add: member
734 member: CN=ldaptestuser2,CN=Users,""" + base_dn + """
735 member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """
736 """)
737     
738     ldb.modify_ldif("""
739 dn: cn=ldaptestgroup2,cn=users,""" + base_dn + """
740 changetype: modify
741 delete: member
742 member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """
743 """)
744     
745     res = ldb.search(base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs)
746     assert len(res) == 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))"
747
748     assertEquals(res[0].dn, ("CN=ldaptestgroup2,CN=Users," + base_dn))
749     assertEquals(res[0]["member"][0], ("CN=ldaptestuser2,CN=Users," + base_dn))
750     assertEquals(len(res[0]["member"]), 1)
751
752     ldb.delete(("CN=ldaptestuser2,CN=Users," + base_dn))
753
754     attrs = ["cn", "name", "objectClass", "objectGUID", "whenCreated", "nTSecurityDescriptor", "member"]
755     print "Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete"
756     res = ldb.search(base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs)
757     assert len(res) == 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete"
758
759     assertEquals(res[0].dn, ("CN=ldaptestgroup2,CN=Users," + base_dn))
760     assert("member" not in res[0])
761
762     print "Testing ldb.search for (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))"
763     res = ldb.search(expression="(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
764     assert len(res) == 1, "Could not find (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))"
765
766     assertEquals(res[0].dn, ("CN=ldaptestutf8user èùéìòà,CN=Users," + base_dn))
767     assertEquals(res[0]["cn"], "ldaptestutf8user èùéìòà")
768     assertEquals(res[0]["name"], "ldaptestutf8user èùéìòà")
769     assertEquals(res[0]["objectClass"], ["top", "person", "organizationalPerson", "user"])
770     assert("objectGUID" in res[0])
771     assert("whenCreated" in res[0])
772
773     ldb.delete(res[0].dn)
774
775     print "Testing ldb.search for (&(cn=ldaptestutf8user2*)(objectClass=user))"
776     res = ldb.search(expression="(&(cn=ldaptestutf8user2*)(objectClass=user))")
777     assert len(res) == 1, "Could not find (&(cn=ldaptestutf8user2*)(objectClass=user))"
778
779     ldb.delete(res[0].dn)
780
781     ldb.delete(("CN=ldaptestgroup2,CN=Users," + base_dn))
782
783     print "Testing ldb.search for (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))"
784     res = ldb.search(expression="(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
785
786     #FIXME: assert len(res) == 1, "Could not find (expect space collapse, win2k3 fails) (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))"
787
788     print "Testing that we can't get at the configuration DN from the main search base"
789     res = ldb.search(base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"])
790     assert len(res) == 0, "Got configuration DN " + res[0].dn + " which should not be able to be seen from main search base"
791     assertEquals(len(res), 0)
792
793     print "Testing that we can get at the configuration DN from the main search base on the LDAP port with the 'phantom root' search_options control"
794     res = ldb.search(base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:2"])
795     assert(len(res) > 0)
796
797     if gc_ldb is not None:
798         print "Testing that we can get at the configuration DN from the main search base on the GC port with the search_options control == 0"
799         
800         res = gc_ldb.search(base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:0"])
801         assert(len(res) > 0)
802
803         print "Testing that we do find configuration elements in the global catlog"
804         res = gc_ldb.search(base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"])
805         assert (len(res) > 0)
806     
807         print "Testing that we do find configuration elements and user elements at the same time"
808         res = gc_ldb.search(base_dn, expression="(|(objectClass=crossRef)(objectClass=person))", scope=SCOPE_SUBTREE, attrs=["cn"])
809         assert (len(res) > 0)
810
811         print "Testing that we do find configuration elements in the global catlog, with the configuration basedn"
812         res = gc_ldb.search(configuration_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"])
813         assert (len(res) > 0)
814
815     print "Testing that we can get at the configuration DN on the main LDAP port"
816     res = ldb.search(configuration_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"])
817     assert (len(res) > 0)
818
819     print "Testing objectCategory canonacolisation"
820     res = ldb.search(configuration_dn, expression="objectCategory=ntDsDSA", scope=SCOPE_SUBTREE, attrs=["cn"])
821     assert len(res) > 0, "Didn't find any records with objectCategory=ntDsDSA"
822     assert(len(res) != 0)
823     
824     res = ldb.search(configuration_dn, expression="objectCategory=CN=ntDs-DSA," + schema_dn, scope=SCOPE_SUBTREE, attrs=["cn"])
825     assert len(res) > 0, "Didn't find any records with objectCategory=CN=ntDs-DSA," + schema_dn
826     assert(len(res) != 0)
827     
828     print "Testing objectClass attribute order on "+ base_dn
829     res = ldb.search(expression="objectClass=domain", base=base_dn, 
830                      scope=SCOPE_BASE, attrs=["objectClass"])
831     assertEquals(len(res), 1)
832
833     assertEquals(res[0]["objectClass"], ["top", "domain", "domainDNS"])
834
835 #  check enumeration
836
837     print "Testing ldb.search for objectCategory=person"
838     res = ldb.search(base_dn, expression="objectCategory=person", scope=SCOPE_SUBTREE, attrs=["cn"])
839     assert(len(res) > 0)
840
841     print "Testing ldb.search for objectCategory=person with domain scope control"
842     res = ldb.search(base_dn, expression="objectCategory=person", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"])
843     assert(len(res) > 0)
844  
845     print "Testing ldb.search for objectCategory=user"
846     res = ldb.search(base_dn, expression="objectCategory=user", scope=SCOPE_SUBTREE, attrs=["cn"])
847     assert(len(res) > 0)
848
849     
850     print "Testing ldb.search for objectCategory=user with domain scope control"
851     res = ldb.search(base_dn, expression="objectCategory=user", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"])
852     assert(len(res) > 0)
853     
854     print "Testing ldb.search for objectCategory=group"
855     res = ldb.search(base_dn, expression="objectCategory=group", scope=SCOPE_SUBTREE, attrs=["cn"])
856     assert(len(res) > 0)
857
858     print "Testing ldb.search for objectCategory=group with domain scope control"
859     res = ldb.search(base_dn, expression="objectCategory=group", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"])
860     assert(len(res) > 0)
861
862 def basedn_tests(ldb, gc_ldb):
863     print "Testing for all rootDSE attributes"
864     res = ldb.search(scope=SCOPE_BASE, attrs=[])
865     assertEquals(len(res), 1)
866
867     print "Testing for highestCommittedUSN"
868     res = ldb.search("", scope=SCOPE_BASE, attrs=["highestCommittedUSN"])
869     assertEquals(len(res), 1)
870     assert(int(res[0]["highestCommittedUSN"][0]) != 0)
871
872     print "Testing for netlogon via LDAP"
873     res = ldb.search("", scope=SCOPE_BASE, attrs=["netlogon"])
874     assertEquals(len(res), 0)
875
876     print "Testing for netlogon and highestCommittedUSN via LDAP"
877     res = ldb.search("", scope=SCOPE_BASE, 
878             attrs=["netlogon", "highestCommittedUSN"])
879     assertEquals(len(res), 0)
880
881
882 def find_basedn(ldb):
883     res = ldb.search(base="", expression="", scope=SCOPE_BASE, 
884                      attrs=["defaultNamingContext"])
885     assertEquals(len(res), 1)
886     return res[0]["defaultNamingContext"][0]
887
888
889 def find_configurationdn(ldb):
890     res = ldb.search(base="", expression="", scope=SCOPE_BASE, attrs=["configurationNamingContext"])
891     assertEquals(len(res), 1)
892     return res[0]["configurationNamingContext"][0]
893
894
895 def find_schemadn(ldb):
896     res = ldb.search(base="", expression="", scope=SCOPE_BASE, attrs=["schemaNamingContext"])
897     assertEquals(len(res), 1)
898     return res[0]["schemaNamingContext"][0]
899
900 if not "://" in host:
901     host = "ldap://%s" % host
902
903 ldb = Ldb(host, credentials=creds, session_info=system_session(), lp=lp)
904 base_dn = find_basedn(ldb)
905 configuration_dn = find_configurationdn(ldb)
906 schema_dn = find_schemadn(ldb)
907
908 print "baseDN: %s\n" % base_dn
909
910 gc_ldb = Ldb("%s:3268" % host, credentials=creds, 
911              session_info=system_session(), lp=lp)
912
913 basic_tests(ldb, gc_ldb, base_dn, configuration_dn, schema_dn)
914 basedn_tests(ldb, gc_ldb)