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