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