source4/dsdb/tests/python/ldap.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3 # This is a port of the original in testprogs/ejs/ldap.js
   4
   5 import optparse
   6 import sys
   7 import time
   8 import base64
   9 import os
  10
  11 sys.path.append("bin/python")
  12 import samba
  13 samba.ensure_external_module("subunit", "subunit/python")
  14 samba.ensure_external_module("testtools", "testtools")
  15
  16 import samba.getopt as options
  17
  18 from samba.auth import system_session
  19 from ldb import SCOPE_SUBTREE, SCOPE_ONELEVEL, SCOPE_BASE, LdbError
  20 from ldb import ERR_NO_SUCH_OBJECT, ERR_ATTRIBUTE_OR_VALUE_EXISTS
  21 from ldb import ERR_ENTRY_ALREADY_EXISTS, ERR_UNWILLING_TO_PERFORM
  22 from ldb import ERR_NOT_ALLOWED_ON_NON_LEAF, ERR_OTHER, ERR_INVALID_DN_SYNTAX
  23 from ldb import ERR_NO_SUCH_ATTRIBUTE, ERR_INVALID_ATTRIBUTE_SYNTAX
  24 from ldb import ERR_OBJECT_CLASS_VIOLATION, ERR_NOT_ALLOWED_ON_RDN
  25 from ldb import ERR_NAMING_VIOLATION, ERR_CONSTRAINT_VIOLATION
  26 from ldb import ERR_UNDEFINED_ATTRIBUTE_TYPE
  27 from ldb import Message, MessageElement, Dn
  28 from ldb import FLAG_MOD_ADD, FLAG_MOD_REPLACE, FLAG_MOD_DELETE
  29 from samba import Ldb
  30 from samba.dsdb import (UF_NORMAL_ACCOUNT, UF_INTERDOMAIN_TRUST_ACCOUNT,
  31     UF_WORKSTATION_TRUST_ACCOUNT, UF_SERVER_TRUST_ACCOUNT,
  32     UF_PARTIAL_SECRETS_ACCOUNT,
  33     UF_PASSWD_NOTREQD, UF_ACCOUNTDISABLE, ATYPE_NORMAL_ACCOUNT,
  34     ATYPE_WORKSTATION_TRUST, SYSTEM_FLAG_DOMAIN_DISALLOW_MOVE,
  35     SYSTEM_FLAG_CONFIG_ALLOW_RENAME, SYSTEM_FLAG_CONFIG_ALLOW_MOVE,
  36     SYSTEM_FLAG_CONFIG_ALLOW_LIMITED_MOVE)
  37 from samba.dcerpc.security import (DOMAIN_RID_USERS, DOMAIN_RID_DOMAIN_MEMBERS,
  38     DOMAIN_RID_DCS, DOMAIN_RID_READONLY_DCS)
  39
  40 from subunit.run import SubunitTestRunner
  41 import unittest
  42
  43 from samba.ndr import ndr_pack, ndr_unpack
  44 from samba.dcerpc import security
  45
  46 parser = optparse.OptionParser("ldap.py [options] <host>")
  47 sambaopts = options.SambaOptions(parser)
  48 parser.add_option_group(sambaopts)
  49 parser.add_option_group(options.VersionOptions(parser))
  50 # use command line creds if available
  51 credopts = options.CredentialsOptions(parser)
  52 parser.add_option_group(credopts)
  53 opts, args = parser.parse_args()
  54
  55 if len(args) < 1:
  56     parser.print_usage()
  57     sys.exit(1)
  58
  59 host = args[0]
  60
  61 lp = sambaopts.get_loadparm()
  62 creds = credopts.get_credentials(lp)
  63
  64 class BasicTests(unittest.TestCase):
  65
  66     def delete_force(self, ldb, dn):
  67         try:
  68             ldb.delete(dn)
  69         except LdbError, (num, _):
  70             self.assertEquals(num, ERR_NO_SUCH_OBJECT)
  71
  72     def find_basedn(self, ldb):
  73         res = ldb.search(base="", expression="", scope=SCOPE_BASE,
  74                          attrs=["defaultNamingContext"])
  75         self.assertEquals(len(res), 1)
  76         return res[0]["defaultNamingContext"][0]
  77
  78     def find_configurationdn(self, ldb):
  79         res = ldb.search(base="", expression="", scope=SCOPE_BASE, attrs=["configurationNamingContext"])
  80         self.assertEquals(len(res), 1)
  81         return res[0]["configurationNamingContext"][0]
  82
  83     def find_schemadn(self, ldb):
  84         res = ldb.search(base="", expression="", scope=SCOPE_BASE, attrs=["schemaNamingContext"])
  85         self.assertEquals(len(res), 1)
  86         return res[0]["schemaNamingContext"][0]
  87
  88     def find_domain_sid(self):
  89         res = self.ldb.search(base=self.base_dn, expression="(objectClass=*)", scope=SCOPE_BASE)
  90         return ndr_unpack( security.dom_sid,res[0]["objectSid"][0])
  91
  92     def set_dsheuristics(self, dsheuristics):
  93         m = Message()
  94         m.dn = Dn(self.ldb, "CN=Directory Service, CN=Windows NT, CN=Services, "
  95                   + self.configuration_dn)
  96         if dsheuristics is not None:
  97             m["dSHeuristics"] = MessageElement(dsheuristics, FLAG_MOD_REPLACE,
  98                                                "dSHeuristics")
  99         else:
 100             m["dSHeuristics"] = MessageElement([], FLAG_MOD_DELETE, "dsHeuristics")
 101         self.ldb.modify(m)
 102
 103     def setUp(self):
 104         super(BasicTests, self).setUp()
 105         self.ldb = ldb
 106         self.gc_ldb = gc_ldb
 107         self.base_dn = self.find_basedn(ldb)
 108         self.configuration_dn = self.find_configurationdn(ldb)
 109         self.schema_dn = self.find_schemadn(ldb)
 110         self.domain_sid = self.find_domain_sid()
 111
 112         print "baseDN: %s\n" % self.base_dn
 113
 114         self.delete_force(self.ldb, "cn=posixuser,cn=users," + self.base_dn)
 115         self.delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 116         self.delete_force(self.ldb, "cn=ldaptestuser2,cn=users," + self.base_dn)
 117         self.delete_force(self.ldb, "cn=ldaptestuser3,cn=users," + self.base_dn)
 118         self.delete_force(self.ldb, "cn=ldaptestuser4,cn=ldaptestcontainer," + self.base_dn)
 119         self.delete_force(self.ldb, "cn=ldaptestuser4,cn=ldaptestcontainer2," + self.base_dn)
 120         self.delete_force(self.ldb, "cn=ldaptestuser5,cn=users," + self.base_dn)
 121         self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 122         self.delete_force(self.ldb, "cn=ldaptestgroup2,cn=users," + self.base_dn)
 123         self.delete_force(self.ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
 124         self.delete_force(self.ldb, "cn=ldaptest2computer,cn=computers," + self.base_dn)
 125         self.delete_force(self.ldb, "cn=ldaptestcomputer3,cn=computers," + self.base_dn)
 126         self.delete_force(self.ldb, "cn=ldaptestutf8user èùéìòà,cn=users," + self.base_dn)
 127         self.delete_force(self.ldb, "cn=ldaptestutf8user2  èùéìòà,cn=users," + self.base_dn)
 128         self.delete_force(self.ldb, "cn=ldaptestcontainer," + self.base_dn)
 129         self.delete_force(self.ldb, "cn=ldaptestcontainer2," + self.base_dn)
 130         self.delete_force(self.ldb, "cn=parentguidtest,cn=users," + self.base_dn)
 131         self.delete_force(self.ldb, "cn=parentguidtest,cn=testotherusers," + self.base_dn)
 132         self.delete_force(self.ldb, "cn=testotherusers," + self.base_dn)
 133         self.delete_force(self.ldb, "cn=ldaptestobject," + self.base_dn)
 134         self.delete_force(self.ldb, "description=xyz,cn=users," + self.base_dn)
 135         self.delete_force(self.ldb, "ou=testou,cn=users," + self.base_dn)
 136         self.delete_force(self.ldb, "cn=testsecret,cn=system," + self.base_dn)
 137
 138     def test_objectclasses(self):
 139         """Test objectClass behaviour"""
 140         print "Test objectClass behaviour"""
 141
 142         # We cannot create LSA-specific objects (oc "secret" or "trustedDomain")
 143         try:
 144             self.ldb.add({
 145                 "dn": "cn=testsecret,cn=system," + self.base_dn,
 146                 "objectClass": "secret" })
 147             self.fail()
 148         except LdbError, (num, _):
 149             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
 150
 151         # Invalid objectclass specified
 152         try:
 153             self.ldb.add({
 154                 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
 155                 "objectClass": "X" })
 156             self.fail()
 157         except LdbError, (num, _):
 158             self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
 159
 160         # Invalid objectCategory specified
 161         try:
 162             self.ldb.add({
 163                 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
 164                 "objectClass": "person",
 165                 "objectCategory": self.base_dn })
 166             self.fail()
 167         except LdbError, (num, _):
 168             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 169
 170         # Multi-valued "systemFlags"
 171         try:
 172             self.ldb.add({
 173                 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
 174                 "objectClass": "person",
 175                 "systemFlags": ["0", str(SYSTEM_FLAG_DOMAIN_DISALLOW_MOVE)] })
 176             self.fail()
 177         except LdbError, (num, _):
 178             self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
 179
 180         # We cannot instanciate from an abstract objectclass
 181         try:
 182             self.ldb.add({
 183                 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
 184                 "objectClass": "connectionPoint" })
 185             self.fail()
 186         except LdbError, (num, _):
 187             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
 188
 189         # Test allowed system flags
 190         self.ldb.add({
 191              "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
 192              "objectClass": "person",
 193              "systemFlags": str(~(SYSTEM_FLAG_CONFIG_ALLOW_RENAME | SYSTEM_FLAG_CONFIG_ALLOW_MOVE | SYSTEM_FLAG_CONFIG_ALLOW_LIMITED_MOVE)) })
 194
 195         res = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
 196                          scope=SCOPE_BASE, attrs=["systemFlags"])
 197         self.assertTrue(len(res) == 1)
 198         self.assertEquals(res[0]["systemFlags"][0], "0")
 199
 200         self.delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 201
 202         self.ldb.add({
 203              "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
 204              "objectClass": "person" })
 205
 206         # We can remove derivation classes of the structural objectclass
 207         # but they're going to be readded afterwards
 208         m = Message()
 209         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 210         m["objectClass"] = MessageElement("top", FLAG_MOD_DELETE,
 211           "objectClass")
 212         ldb.modify(m)
 213
 214         res = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
 215                          scope=SCOPE_BASE, attrs=["objectClass"])
 216         self.assertTrue(len(res) == 1)
 217         self.assertTrue("top" in res[0]["objectClass"])
 218
 219         # The top-most structural class cannot be deleted since there are
 220         # attributes of it in use
 221         m = Message()
 222         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 223         m["objectClass"] = MessageElement("person", FLAG_MOD_DELETE,
 224           "objectClass")
 225         try:
 226             ldb.modify(m)
 227             self.fail()
 228         except LdbError, (num, _):
 229             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 230
 231         # We cannot delete classes which weren't specified
 232         m = Message()
 233         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 234         m["objectClass"] = MessageElement("computer", FLAG_MOD_DELETE,
 235           "objectClass")
 236         try:
 237             ldb.modify(m)
 238             self.fail()
 239         except LdbError, (num, _):
 240             self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
 241
 242         # An invalid class cannot be added
 243         m = Message()
 244         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 245         m["objectClass"] = MessageElement("X", FLAG_MOD_ADD,
 246           "objectClass")
 247         try:
 248             ldb.modify(m)
 249             self.fail()
 250         except LdbError, (num, _):
 251             self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
 252
 253         # The top-most structural class cannot be changed by adding another
 254         # structural one
 255         m = Message()
 256         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 257         m["objectClass"] = MessageElement("user", FLAG_MOD_ADD,
 258           "objectClass")
 259         try:
 260             ldb.modify(m)
 261             self.fail()
 262         except LdbError, (num, _):
 263             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 264
 265         # An already specified objectclass cannot be added another time
 266         m = Message()
 267         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 268         m["objectClass"] = MessageElement("person", FLAG_MOD_ADD,
 269           "objectClass")
 270         try:
 271             ldb.modify(m)
 272             self.fail()
 273         except LdbError, (num, _):
 274             self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
 275
 276         # Auxiliary classes can always be added
 277         m = Message()
 278         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 279         m["objectClass"] = MessageElement("bootableDevice", FLAG_MOD_ADD,
 280           "objectClass")
 281         ldb.modify(m)
 282
 283         # It's only possible to replace with the same objectclass combination.
 284         # So the replace action on "objectClass" attributes is really useless.
 285         m = Message()
 286         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 287         m["objectClass"] = MessageElement(["top", "person", "bootableDevice"],
 288           FLAG_MOD_REPLACE, "objectClass")
 289         ldb.modify(m)
 290
 291         m = Message()
 292         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 293         m["objectClass"] = MessageElement(["person", "bootableDevice"],
 294           FLAG_MOD_REPLACE, "objectClass")
 295         ldb.modify(m)
 296
 297         m = Message()
 298         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 299         m["objectClass"] = MessageElement(["top", "person", "bootableDevice",
 300           "connectionPoint"], FLAG_MOD_REPLACE, "objectClass")
 301         try:
 302             ldb.modify(m)
 303             self.fail()
 304         except LdbError, (num, _):
 305             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 306
 307         m = Message()
 308         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 309         m["objectClass"] = MessageElement(["top", "computer"], FLAG_MOD_REPLACE,
 310           "objectClass")
 311         try:
 312             ldb.modify(m)
 313             self.fail()
 314         except LdbError, (num, _):
 315             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 316
 317         # Classes can be removed unless attributes of them are used.
 318         m = Message()
 319         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 320         m["objectClass"] = MessageElement("bootableDevice", FLAG_MOD_DELETE,
 321           "objectClass")
 322         ldb.modify(m)
 323
 324         res = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
 325                          scope=SCOPE_BASE, attrs=["objectClass"])
 326         self.assertTrue(len(res) == 1)
 327         self.assertFalse("bootableDevice" in res[0]["objectClass"])
 328
 329         m = Message()
 330         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 331         m["objectClass"] = MessageElement("bootableDevice", FLAG_MOD_ADD,
 332           "objectClass")
 333         ldb.modify(m)
 334
 335         # Add an attribute specific to the "bootableDevice" class
 336         m = Message()
 337         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 338         m["bootParameter"] = MessageElement("test", FLAG_MOD_ADD,
 339           "bootParameter")
 340         ldb.modify(m)
 341
 342         # Classes can be removed unless attributes of them are used. Now there
 343         # exist such attributes on the entry.
 344         m = Message()
 345         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 346         m["objectClass"] = MessageElement("bootableDevice", FLAG_MOD_DELETE,
 347           "objectClass")
 348         try:
 349             ldb.modify(m)
 350             self.fail()
 351         except LdbError, (num, _):
 352             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 353
 354         # Remove the previously specified attribute
 355         m = Message()
 356         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 357         m["bootParameter"] = MessageElement("test", FLAG_MOD_DELETE,
 358           "bootParameter")
 359         ldb.modify(m)
 360
 361         # Classes can be removed unless attributes of them are used.
 362         m = Message()
 363         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 364         m["objectClass"] = MessageElement("bootableDevice", FLAG_MOD_DELETE,
 365           "objectClass")
 366         ldb.modify(m)
 367
 368         self.delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 369
 370     def test_system_only(self):
 371         """Test systemOnly objects"""
 372         print "Test systemOnly objects"""
 373
 374         try:
 375             self.ldb.add({
 376                 "dn": "cn=ldaptestobject," + self.base_dn,
 377                 "objectclass": "configuration"})
 378             self.fail()
 379         except LdbError, (num, _):
 380             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
 381
 382         try:
 383             self.ldb.add({
 384                 "dn": "cn=testsecret,cn=system," + self.base_dn,
 385                 "objectclass": "secret"})
 386             self.fail()
 387         except LdbError, (num, _):
 388             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
 389
 390         self.delete_force(self.ldb, "cn=ldaptestobject," + self.base_dn)
 391         self.delete_force(self.ldb, "cn=testsecret,cn=system," + self.base_dn)
 392
 393         try:
 394             self.ldb.add({
 395                 "dn": "cn=ldaptestcontainer," + self.base_dn,
 396                 "objectclass": "container",
 397                 "isCriticalSystemObject": "TRUE"})
 398             self.fail()
 399         except LdbError, (num, _):
 400             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
 401
 402         self.ldb.add({
 403             "dn": "cn=ldaptestcontainer," + self.base_dn,
 404             "objectclass": "container"})
 405
 406         m = Message()
 407         m.dn = Dn(ldb, "cn=ldaptestcontainer," + self.base_dn)
 408         m["isCriticalSystemObject"] = MessageElement("TRUE", FLAG_MOD_REPLACE,
 409           "isCriticalSystemObject")
 410         try:
 411             ldb.modify(m)
 412             self.fail()
 413         except LdbError, (num, _):
 414             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
 415
 416         self.delete_force(self.ldb, "cn=ldaptestcontainer," + self.base_dn)
 417
 418         # Proof if DC SAM object has "isCriticalSystemObject" set
 419         res = self.ldb.search("", scope=SCOPE_BASE, attrs=["serverName"])
 420         self.assertTrue(len(res) == 1)
 421         self.assertTrue("serverName" in res[0])
 422         res = self.ldb.search(res[0]["serverName"][0], scope=SCOPE_BASE,
 423                               attrs=["serverReference"])
 424         self.assertTrue(len(res) == 1)
 425         self.assertTrue("serverReference" in res[0])
 426         res = self.ldb.search(res[0]["serverReference"][0], scope=SCOPE_BASE,
 427                               attrs=["isCriticalSystemObject"])
 428         self.assertTrue(len(res) == 1)
 429         self.assertTrue("isCriticalSystemObject" in res[0])
 430         self.assertEquals(res[0]["isCriticalSystemObject"][0], "TRUE")
 431
 432     def test_invalid_parent(self):
 433         """Test adding an object with invalid parent"""
 434         print "Test adding an object with invalid parent"""
 435
 436         try:
 437             self.ldb.add({
 438                 "dn": "cn=ldaptestgroup,cn=thisdoesnotexist123,"
 439                    + self.base_dn,
 440                 "objectclass": "group"})
 441             self.fail()
 442         except LdbError, (num, _):
 443             self.assertEquals(num, ERR_NO_SUCH_OBJECT)
 444
 445         self.delete_force(self.ldb, "cn=ldaptestgroup,cn=thisdoesnotexist123,"
 446           + self.base_dn)
 447
 448         try:
 449             self.ldb.add({
 450                 "dn": "ou=testou,cn=users," + self.base_dn,
 451                 "objectclass": "organizationalUnit"})
 452             self.fail()
 453         except LdbError, (num, _):
 454             self.assertEquals(num, ERR_NAMING_VIOLATION)
 455
 456         self.delete_force(self.ldb, "ou=testou,cn=users," + self.base_dn)
 457
 458     def test_invalid_attribute(self):
 459         """Test invalid attributes on schema/objectclasses"""
 460         print "Test invalid attributes on schema/objectclasses"""
 461
 462         # attributes not in schema test
 463
 464         # add operation
 465
 466         try:
 467             self.ldb.add({
 468                 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
 469                 "objectclass": "group",
 470                 "thisdoesnotexist": "x"})
 471             self.fail()
 472         except LdbError, (num, _):
 473             self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
 474
 475         self.ldb.add({
 476              "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
 477              "objectclass": "group"})
 478
 479         # modify operation
 480
 481         m = Message()
 482         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 483         m["thisdoesnotexist"] = MessageElement("x", FLAG_MOD_REPLACE,
 484           "thisdoesnotexist")
 485         try:
 486             ldb.modify(m)
 487             self.fail()
 488         except LdbError, (num, _):
 489             self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
 490
 491         self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 492
 493         # attributes not in objectclasses and mandatory attributes missing test
 494         # Use here a non-SAM entry since it doesn't have special triggers
 495         # associated which have an impact on the error results.
 496
 497         # add operations
 498
 499         # mandatory attribute missing
 500         try:
 501             self.ldb.add({
 502                 "dn": "cn=ldaptestobject," + self.base_dn,
 503                 "objectclass": "ipProtocol"})
 504             self.fail()
 505         except LdbError, (num, _):
 506             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 507
 508         # inadequate but schema-valid attribute specified
 509         try:
 510             self.ldb.add({
 511                 "dn": "cn=ldaptestobject," + self.base_dn,
 512                 "objectclass": "ipProtocol",
 513                 "ipProtocolNumber": "1",
 514                 "uid" : "0"})
 515             self.fail()
 516         except LdbError, (num, _):
 517             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 518
 519         self.ldb.add({
 520             "dn": "cn=ldaptestobject," + self.base_dn,
 521             "objectclass": "ipProtocol",
 522             "ipProtocolNumber": "1"})
 523
 524         # modify operations
 525
 526         # inadequate but schema-valid attribute add trial
 527         m = Message()
 528         m.dn = Dn(ldb, "cn=ldaptestobject," + self.base_dn)
 529         m["uid"] = MessageElement("0", FLAG_MOD_ADD, "uid")
 530         try:
 531             ldb.modify(m)
 532             self.fail()
 533         except LdbError, (num, _):
 534             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 535
 536         # mandatory attribute delete trial
 537         m = Message()
 538         m.dn = Dn(ldb, "cn=ldaptestobject," + self.base_dn)
 539         m["ipProtocolNumber"] = MessageElement([], FLAG_MOD_DELETE,
 540           "ipProtocolNumber")
 541         try:
 542             ldb.modify(m)
 543             self.fail()
 544         except LdbError, (num, _):
 545             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 546
 547         # mandatory attribute delete trial
 548         m = Message()
 549         m.dn = Dn(ldb, "cn=ldaptestobject," + self.base_dn)
 550         m["ipProtocolNumber"] = MessageElement([], FLAG_MOD_REPLACE,
 551           "ipProtocolNumber")
 552         try:
 553             ldb.modify(m)
 554             self.fail()
 555         except LdbError, (num, _):
 556             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 557
 558         self.delete_force(self.ldb, "cn=ldaptestobject," + self.base_dn)
 559
 560     def test_single_valued_attributes(self):
 561         """Test single-valued attributes"""
 562         print "Test single-valued attributes"""
 563
 564         try:
 565             self.ldb.add({
 566                 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
 567                 "objectclass": "group",
 568                 "sAMAccountName": ["nam1", "nam2"]})
 569             self.fail()
 570         except LdbError, (num, _):
 571             self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
 572
 573         self.ldb.add({
 574              "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
 575              "objectclass": "group"})
 576
 577         m = Message()
 578         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 579         m["sAMAccountName"] = MessageElement(["nam1","nam2"], FLAG_MOD_REPLACE,
 580           "sAMAccountName")
 581         try:
 582             ldb.modify(m)
 583             self.fail()
 584         except LdbError, (num, _):
 585             self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
 586
 587         m = Message()
 588         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 589         m["sAMAccountName"] = MessageElement("testgroupXX", FLAG_MOD_REPLACE,
 590           "sAMAccountName")
 591         ldb.modify(m)
 592
 593         m = Message()
 594         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 595         m["sAMAccountName"] = MessageElement("testgroupXX2", FLAG_MOD_ADD,
 596           "sAMAccountName")
 597         try:
 598             ldb.modify(m)
 599             self.fail()
 600         except LdbError, (num, _):
 601             self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
 602
 603         self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 604
 605     def test_description_attribute(self):
 606         """Test description attribute"""
 607         print "Test description attribute"""
 608
 609         self.ldb.add({
 610             "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
 611             "description": "desc2",
 612             "objectclass": "group",
 613             "description": "desc1"})
 614
 615         res = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
 616                          scope=SCOPE_BASE, attrs=["description"])
 617         self.assertTrue(len(res) == 1)
 618         self.assertTrue("description" in res[0])
 619         self.assertTrue(len(res[0]["description"]) == 1)
 620         self.assertEquals(res[0]["description"][0], "desc1")
 621
 622         self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 623
 624         self.ldb.add({
 625             "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
 626             "objectclass": "group",
 627             "description": ["desc1", "desc2"]})
 628
 629         res = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
 630                          scope=SCOPE_BASE, attrs=["description"])
 631         self.assertTrue(len(res) == 1)
 632         self.assertTrue("description" in res[0])
 633         self.assertTrue(len(res[0]["description"]) == 2)
 634         self.assertTrue(res[0]["description"][0] == "desc1" or
 635                         res[0]["description"][1] == "desc1")
 636         self.assertTrue(res[0]["description"][0] == "desc2" or
 637                         res[0]["description"][1] == "desc2")
 638
 639         m = Message()
 640         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 641         m["description"] = MessageElement(["desc1","desc2"], FLAG_MOD_REPLACE,
 642           "description")
 643         try:
 644             ldb.modify(m)
 645             self.fail()
 646         except LdbError, (num, _):
 647             self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
 648
 649         m = Message()
 650         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 651         m["description"] = MessageElement(["desc1","desc2"], FLAG_MOD_DELETE,
 652           "description")
 653         ldb.modify(m)
 654
 655         self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 656
 657         self.ldb.add({
 658             "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
 659             "objectclass": "group" })
 660
 661         m = Message()
 662         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 663         m["description"] = MessageElement("desc1", FLAG_MOD_REPLACE,
 664           "description")
 665         ldb.modify(m)
 666
 667         res = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
 668                          scope=SCOPE_BASE, attrs=["description"])
 669         self.assertTrue(len(res) == 1)
 670         self.assertTrue("description" in res[0])
 671         self.assertTrue(len(res[0]["description"]) == 1)
 672         self.assertEquals(res[0]["description"][0], "desc1")
 673
 674         self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 675
 676         self.ldb.add({
 677             "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
 678             "objectclass": "group",
 679             "description": ["desc1", "desc2"]})
 680
 681         m = Message()
 682         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 683         m["description"] = MessageElement("desc1", FLAG_MOD_REPLACE,
 684           "description")
 685         ldb.modify(m)
 686
 687         res = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
 688                          scope=SCOPE_BASE, attrs=["description"])
 689         self.assertTrue(len(res) == 1)
 690         self.assertTrue("description" in res[0])
 691         self.assertTrue(len(res[0]["description"]) == 1)
 692         self.assertEquals(res[0]["description"][0], "desc1")
 693
 694         m = Message()
 695         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 696         m["description"] = MessageElement("desc3", FLAG_MOD_ADD,
 697           "description")
 698         try:
 699             ldb.modify(m)
 700             self.fail()
 701         except LdbError, (num, _):
 702             self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
 703
 704         m = Message()
 705         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 706         m["description"] = MessageElement(["desc1","desc2"], FLAG_MOD_DELETE,
 707           "description")
 708         try:
 709             ldb.modify(m)
 710             self.fail()
 711         except LdbError, (num, _):
 712             self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
 713
 714         m = Message()
 715         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 716         m["description"] = MessageElement("desc1", FLAG_MOD_DELETE,
 717           "description")
 718         ldb.modify(m)
 719         res = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
 720                          scope=SCOPE_BASE, attrs=["description"])
 721         self.assertTrue(len(res) == 1)
 722         self.assertFalse("description" in res[0])
 723
 724         m = Message()
 725         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 726         m["description"] = MessageElement(["desc1","desc2"], FLAG_MOD_REPLACE,
 727           "description")
 728         try:
 729             ldb.modify(m)
 730             self.fail()
 731         except LdbError, (num, _):
 732             self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
 733
 734         m = Message()
 735         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 736         m["description"] = MessageElement(["desc3", "desc4"], FLAG_MOD_ADD,
 737           "description")
 738         try:
 739             ldb.modify(m)
 740             self.fail()
 741         except LdbError, (num, _):
 742             self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
 743
 744         m = Message()
 745         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 746         m["description"] = MessageElement("desc1", FLAG_MOD_ADD,
 747           "description")
 748         ldb.modify(m)
 749
 750         res = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
 751                          scope=SCOPE_BASE, attrs=["description"])
 752         self.assertTrue(len(res) == 1)
 753         self.assertTrue("description" in res[0])
 754         self.assertTrue(len(res[0]["description"]) == 1)
 755         self.assertEquals(res[0]["description"][0], "desc1")
 756
 757         self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 758
 759     def test_attribute_ranges(self):
 760         """Test attribute ranges"""
 761         print "Test attribute ranges"""
 762
 763         # Too short (min. 1)
 764         try:
 765             ldb.add({
 766                "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
 767                "objectClass": "person",
 768                "sn": "" })
 769             self.fail()
 770         except LdbError, (num, _):
 771             self.assertEquals(num, ERR_INVALID_ATTRIBUTE_SYNTAX)
 772
 773         # Too long (max. 64)
 774 #        try:
 775 #            ldb.add({
 776 #               "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
 777 #               "objectClass": "person",
 778 #               "sn": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" })
 779 #            self.fail()
 780 #        except LdbError, (num, _):
 781 #            self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
 782
 783         ldb.add({
 784            "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
 785            "objectClass": "person" })
 786
 787         # Too short (min. 1)
 788         m = Message()
 789         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 790         m["sn"] = MessageElement("", FLAG_MOD_REPLACE, "sn")
 791         try:
 792             ldb.modify(m)
 793             self.fail()
 794         except LdbError, (num, _):
 795             self.assertEquals(num, ERR_INVALID_ATTRIBUTE_SYNTAX)
 796
 797         # Too long (max. 64)
 798 #        m = Message()
 799 #        m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 800 #        m["sn"] = MessageElement("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", FLAG_MOD_REPLACE, "sn")
 801 #        try:
 802 #            ldb.modify(m)
 803 #            self.fail()
 804 #        except LdbError, (num, _):
 805 #            self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
 806
 807         m = Message()
 808         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 809         m["sn"] = MessageElement("x", FLAG_MOD_REPLACE, "sn")
 810         ldb.modify(m)
 811
 812         self.delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 813
 814     def test_empty_messages(self):
 815         """Test empty messages"""
 816         print "Test empty messages"""
 817
 818         m = Message()
 819         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 820
 821         try:
 822             ldb.add(m)
 823             self.fail()
 824         except LdbError, (num, _):
 825             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 826
 827         try:
 828             ldb.modify(m)
 829             self.fail()
 830         except LdbError, (num, _):
 831             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
 832
 833         self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 834
 835     def test_empty_attributes(self):
 836         """Test empty attributes"""
 837         print "Test empty attributes"""
 838
 839         m = Message()
 840         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 841         m["objectClass"] = MessageElement("group", FLAG_MOD_ADD, "objectClass")
 842         m["description"] = MessageElement([], FLAG_MOD_ADD, "description")
 843
 844         try:
 845             ldb.add(m)
 846             self.fail()
 847         except LdbError, (num, _):
 848             self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
 849
 850         self.ldb.add({
 851             "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
 852             "objectclass": "group"})
 853
 854         m = Message()
 855         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 856         m["description"] = MessageElement([], FLAG_MOD_ADD, "description")
 857
 858         try:
 859             ldb.modify(m)
 860             self.fail()
 861         except LdbError, (num, _):
 862             self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
 863
 864         m = Message()
 865         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 866         m["description"] = MessageElement([], FLAG_MOD_REPLACE, "description")
 867         ldb.modify(m)
 868
 869         m = Message()
 870         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 871         m["description"] = MessageElement([], FLAG_MOD_DELETE, "description")
 872         try:
 873             ldb.modify(m)
 874             self.fail()
 875         except LdbError, (num, _):
 876             self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
 877
 878         self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 879
 880     def test_instanceType(self):
 881         """Tests the 'instanceType' attribute"""
 882         print "Tests the 'instanceType' attribute"""
 883
 884         # The instance type is single-valued
 885         try:
 886             self.ldb.add({
 887                 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
 888                 "objectclass": "group",
 889                 "instanceType": ["0", "1"]})
 890             self.fail()
 891         except LdbError, (num, _):
 892             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
 893
 894         # The head NC flag cannot be set without the write flag
 895         try:
 896             self.ldb.add({
 897                 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
 898                 "objectclass": "group",
 899                 "instanceType": "1" })
 900             self.fail()
 901         except LdbError, (num, _):
 902             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
 903
 904         # We cannot manipulate NCs without the head NC flag
 905         try:
 906             self.ldb.add({
 907                 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
 908                 "objectclass": "group",
 909                 "instanceType": "32" })
 910             self.fail()
 911         except LdbError, (num, _):
 912             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
 913
 914         self.ldb.add({
 915              "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
 916              "objectclass": "group"})
 917
 918         m = Message()
 919         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 920         m["instanceType"] = MessageElement("0", FLAG_MOD_REPLACE,
 921           "instanceType")
 922         try:
 923             ldb.modify(m)
 924             self.fail()
 925         except LdbError, (num, _):
 926             self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
 927
 928         m = Message()
 929         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 930         m["instanceType"] = MessageElement([], FLAG_MOD_REPLACE,
 931           "instanceType")
 932         try:
 933             ldb.modify(m)
 934             self.fail()
 935         except LdbError, (num, _):
 936             self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
 937
 938         m = Message()
 939         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 940         m["instanceType"] = MessageElement([], FLAG_MOD_DELETE, "instanceType")
 941         try:
 942             ldb.modify(m)
 943             self.fail()
 944         except LdbError, (num, _):
 945             self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
 946
 947         self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 948
 949     def test_distinguished_name(self):
 950         """Tests the 'distinguishedName' attribute"""
 951         print "Tests the 'distinguishedName' attribute"""
 952
 953         # a wrong "distinguishedName" attribute is obviously tolerated
 954         self.ldb.add({
 955               "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
 956               "objectclass": "group",
 957               "distinguishedName": "cn=ldaptest,cn=users," + self.base_dn})
 958
 959         # proof if the DN has been set correctly
 960         res = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
 961                          scope=SCOPE_BASE, attrs=["distinguishedName"])
 962         self.assertTrue(len(res) == 1)
 963         self.assertTrue("distinguishedName" in res[0])
 964         self.assertTrue(Dn(ldb, res[0]["distinguishedName"][0])
 965            == Dn(ldb, "cn=ldaptestgroup, cn=users," + self.base_dn))
 966
 967         m = Message()
 968         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 969         m["distinguishedName"] = MessageElement(
 970           "cn=ldaptestuser,cn=users," + self.base_dn, FLAG_MOD_ADD,
 971           "distinguishedName")
 972
 973         try:
 974             ldb.modify(m)
 975             self.fail()
 976         except LdbError, (num, _):
 977             self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
 978
 979         m = Message()
 980         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 981         m["distinguishedName"] = MessageElement(
 982           "cn=ldaptestuser,cn=users," + self.base_dn, FLAG_MOD_REPLACE,
 983           "distinguishedName")
 984
 985         try:
 986             ldb.modify(m)
 987             self.fail()
 988         except LdbError, (num, _):
 989             self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
 990
 991         m = Message()
 992         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 993         m["distinguishedName"] = MessageElement(
 994           "cn=ldaptestuser,cn=users," + self.base_dn, FLAG_MOD_DELETE,
 995           "distinguishedName")
 996
 997         try:
 998             ldb.modify(m)
 999             self.fail()
1000         except LdbError, (num, _):
1001             self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
1002
1003         self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1004
1005     def test_rdn_name(self):
1006         """Tests the RDN"""
1007         print "Tests the RDN"""
1008
1009         try:
1010             self.ldb.add({
1011                  "dn": "description=xyz,cn=users," + self.base_dn,
1012                  "objectclass": "group"})
1013             self.fail()
1014         except LdbError, (num, _):
1015             self.assertEquals(num, ERR_NAMING_VIOLATION)
1016
1017         self.delete_force(self.ldb, "description=xyz,cn=users," + self.base_dn)
1018
1019         # a wrong "name" attribute is obviously tolerated
1020         self.ldb.add({
1021              "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
1022              "objectclass": "group",
1023              "name": "ldaptestgroupx"})
1024
1025         # proof if the name has been set correctly
1026         res = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
1027                          scope=SCOPE_BASE, attrs=["name"])
1028         self.assertTrue(len(res) == 1)
1029         self.assertTrue("name" in res[0])
1030         self.assertTrue(res[0]["name"][0] == "ldaptestgroup")
1031
1032         m = Message()
1033         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1034         m["name"] = MessageElement("cn=ldaptestuser", FLAG_MOD_REPLACE,
1035           "name")
1036         try:
1037             ldb.modify(m)
1038             self.fail()
1039         except LdbError, (num, _):
1040             self.assertEquals(num, ERR_NOT_ALLOWED_ON_RDN)
1041
1042         m = Message()
1043         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1044         m["cn"] = MessageElement("ldaptestuser",
1045           FLAG_MOD_REPLACE, "cn")
1046         try:
1047             ldb.modify(m)
1048             self.fail()
1049         except LdbError, (num, _):
1050             self.assertEquals(num, ERR_NOT_ALLOWED_ON_RDN)
1051
1052         self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1053
1054
1055         # this test needs to be disabled until we really understand
1056         # what the rDN length constraints are
1057     def DISABLED_test_largeRDN(self):
1058         """Testing large rDN (limit 64 characters)"""
1059         rdn = "CN=a012345678901234567890123456789012345678901234567890123456789012";
1060         self.delete_force(self.ldb, "%s,%s" % (rdn, self.base_dn))
1061         ldif = """
1062 dn: %s,%s""" % (rdn,self.base_dn) + """
1063 objectClass: container
1064 """
1065         self.ldb.add_ldif(ldif)
1066         self.delete_force(self.ldb, "%s,%s" % (rdn, self.base_dn))
1067
1068         rdn = "CN=a0123456789012345678901234567890123456789012345678901234567890120";
1069         self.delete_force(self.ldb, "%s,%s" % (rdn, self.base_dn))
1070         try:
1071             ldif = """
1072 dn: %s,%s""" % (rdn,self.base_dn) + """
1073 objectClass: container
1074 """
1075             self.ldb.add_ldif(ldif)
1076             self.fail()
1077         except LdbError, (num, _):
1078             self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
1079         self.delete_force(self.ldb, "%s,%s" % (rdn, self.base_dn))
1080
1081     def test_rename(self):
1082         """Tests the rename operation"""
1083         print "Tests the rename operations"""
1084
1085         try:
1086             # cannot rename to be a child of itself
1087             ldb.rename(self.base_dn, "dc=test," + self.base_dn)
1088             self.fail()
1089         except LdbError, (num, _):
1090             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1091
1092         try:
1093             # inexistent object
1094             ldb.rename("cn=ldaptestuser2,cn=users," + self.base_dn, "cn=ldaptestuser2,cn=users," + self.base_dn)
1095             self.fail()
1096         except LdbError, (num, _):
1097             self.assertEquals(num, ERR_NO_SUCH_OBJECT)
1098
1099         self.ldb.add({
1100              "dn": "cn=ldaptestuser2,cn=users," + self.base_dn,
1101              "objectclass": ["user", "person"] })
1102
1103         ldb.rename("cn=ldaptestuser2,cn=users," + self.base_dn, "cn=ldaptestuser2,cn=users," + self.base_dn)
1104         ldb.rename("cn=ldaptestuser2,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=users," + self.base_dn)
1105         ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestUSER3,cn=users," + self.base_dn)
1106
1107         try:
1108             # containment problem: a user entry cannot contain user entries
1109             ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser4,cn=ldaptestuser3,cn=users," + self.base_dn)
1110             self.fail()
1111         except LdbError, (num, _):
1112             self.assertEquals(num, ERR_NAMING_VIOLATION)
1113
1114         try:
1115             # invalid parent
1116             ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=people,cn=users," + self.base_dn)
1117             self.fail()
1118         except LdbError, (num, _):
1119             self.assertEquals(num, ERR_OTHER)
1120
1121         try:
1122             # invalid target DN syntax
1123             ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, ",cn=users," + self.base_dn)
1124             self.fail()
1125         except LdbError, (num, _):
1126             self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
1127
1128         try:
1129             # invalid RDN name
1130             ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "ou=ldaptestuser3,cn=users," + self.base_dn)
1131             self.fail()
1132         except LdbError, (num, _):
1133             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1134
1135         self.delete_force(self.ldb, "cn=ldaptestuser3,cn=users," + self.base_dn)
1136
1137         # Performs some "systemFlags" testing
1138
1139         # Move failing since no "SYSTEM_FLAG_CONFIG_ALLOW_MOVE"
1140         try:
1141             ldb.rename("CN=DisplaySpecifiers," + self.configuration_dn, "CN=DisplaySpecifiers,CN=Services," + self.configuration_dn)
1142             self.fail()
1143         except LdbError, (num, _):
1144             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1145
1146         # Limited move failing since no "SYSTEM_FLAG_CONFIG_ALLOW_LIMITED_MOVE"
1147         try:
1148             ldb.rename("CN=Directory Service,CN=Windows NT,CN=Services," + self.configuration_dn, "CN=Directory Service,CN=RRAS,CN=Services," + self.configuration_dn)
1149             self.fail()
1150         except LdbError, (num, _):
1151             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1152
1153         # Rename failing since no "SYSTEM_FLAG_CONFIG_ALLOW_RENAME"
1154         try:
1155             ldb.rename("CN=DisplaySpecifiers," + self.configuration_dn, "CN=DisplaySpecifiers2," + self.configuration_dn)
1156             self.fail()
1157         except LdbError, (num, _):
1158             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1159
1160         # It's not really possible to test moves on the schema partition since
1161         # there don't exist subcontainers on it.
1162
1163         # Rename failing since "SYSTEM_FLAG_SCHEMA_BASE_OBJECT"
1164         try:
1165             ldb.rename("CN=Top," + self.schema_dn, "CN=Top2," + self.schema_dn)
1166             self.fail()
1167         except LdbError, (num, _):
1168             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1169
1170         # Move failing since "SYSTEM_FLAG_DOMAIN_DISALLOW_MOVE"
1171         try:
1172             ldb.rename("CN=Users," + self.base_dn, "CN=Users,CN=Computers," + self.base_dn)
1173             self.fail()
1174         except LdbError, (num, _):
1175             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1176
1177         # Rename failing since "SYSTEM_FLAG_DOMAIN_DISALLOW_RENAME"
1178         try:
1179             ldb.rename("CN=Users," + self.base_dn, "CN=Users2," + self.base_dn)
1180             self.fail()
1181         except LdbError, (num, _):
1182             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1183
1184         # Performs some other constraints testing
1185
1186         try:
1187             ldb.rename("CN=Policies,CN=System," + self.base_dn, "CN=Users2," + self.base_dn)
1188             self.fail()
1189         except LdbError, (num, _):
1190             self.assertEquals(num, ERR_OTHER)
1191
1192     def test_rename_twice(self):
1193         """Tests the rename operation twice - this corresponds to a past bug"""
1194         print "Tests the rename twice operation"""
1195
1196         self.ldb.add({
1197              "dn": "cn=ldaptestuser5,cn=users," + self.base_dn,
1198              "objectclass": ["user", "person"] })
1199
1200         ldb.rename("cn=ldaptestuser5,cn=users," + self.base_dn, "cn=ldaptestUSER5,cn=users," + self.base_dn)
1201         self.delete_force(self.ldb, "cn=ldaptestuser5,cn=users," + self.base_dn)
1202         self.ldb.add({
1203              "dn": "cn=ldaptestuser5,cn=users," + self.base_dn,
1204              "objectclass": ["user", "person"] })
1205         ldb.rename("cn=ldaptestuser5,cn=Users," + self.base_dn, "cn=ldaptestUSER5,cn=users," + self.base_dn)
1206         res = ldb.search(expression="cn=ldaptestuser5")
1207         print "Found %u records" % len(res)
1208         self.assertEquals(len(res), 1, "Wrong number of hits for cn=ldaptestuser5")
1209         res = ldb.search(expression="(&(cn=ldaptestuser5)(objectclass=user))")
1210         print "Found %u records" % len(res)
1211         self.assertEquals(len(res), 1, "Wrong number of hits for (&(cn=ldaptestuser5)(objectclass=user))")
1212         self.delete_force(self.ldb, "cn=ldaptestuser5,cn=users," + self.base_dn)
1213
1214     def test_parentGUID(self):
1215         """Test parentGUID behaviour"""
1216         print "Testing parentGUID behaviour\n"
1217
1218         # TODO: This seems to fail on Windows Server. Hidden attribute?
1219
1220         self.ldb.add({
1221             "dn": "cn=parentguidtest,cn=users," + self.base_dn,
1222             "objectclass":"user",
1223             "samaccountname":"parentguidtest"});
1224         res1 = ldb.search(base="cn=parentguidtest,cn=users," + self.base_dn, scope=SCOPE_BASE,
1225                           attrs=["parentGUID", "samaccountname"]);
1226         res2 = ldb.search(base="cn=users," + self.base_dn,scope=SCOPE_BASE,
1227                           attrs=["objectGUID"]);
1228         res3 = ldb.search(base=self.base_dn, scope=SCOPE_BASE,
1229                           attrs=["parentGUID"]);
1230         res4 = ldb.search(base=self.configuration_dn, scope=SCOPE_BASE,
1231                           attrs=["parentGUID"]);
1232         res5 = ldb.search(base=self.schema_dn, scope=SCOPE_BASE,
1233                           attrs=["parentGUID"]);
1234
1235         """Check if the parentGUID is valid """
1236         self.assertEquals(res1[0]["parentGUID"], res2[0]["objectGUID"]);
1237
1238         """Check if it returns nothing when there is no parent object - default NC"""
1239         has_parentGUID = False
1240         for key in res3[0].keys():
1241             if key == "parentGUID":
1242                 has_parentGUID = True
1243                 break
1244         self.assertFalse(has_parentGUID);
1245
1246         """Check if it returns nothing when there is no parent object - configuration NC"""
1247         has_parentGUID = False
1248         for key in res4[0].keys():
1249             if key == "parentGUID":
1250                 has_parentGUID = True
1251                 break
1252         self.assertFalse(has_parentGUID);
1253
1254         """Check if it returns nothing when there is no parent object - schema NC"""
1255         has_parentGUID = False
1256         for key in res5[0].keys():
1257             if key == "parentGUID":
1258                 has_parentGUID = True
1259                 break
1260         self.assertFalse(has_parentGUID);
1261
1262         """Ensures that if you look for another object attribute after the constructed
1263             parentGUID, it will return correctly"""
1264         has_another_attribute = False
1265         for key in res1[0].keys():
1266             if key == "sAMAccountName":
1267                 has_another_attribute = True
1268                 break
1269         self.assertTrue(has_another_attribute)
1270         self.assertTrue(len(res1[0]["samaccountname"]) == 1)
1271         self.assertEquals(res1[0]["samaccountname"][0], "parentguidtest");
1272
1273         print "Testing parentGUID behaviour on rename\n"
1274
1275         self.ldb.add({
1276             "dn": "cn=testotherusers," + self.base_dn,
1277             "objectclass":"container"});
1278         res1 = ldb.search(base="cn=testotherusers," + self.base_dn,scope=SCOPE_BASE,
1279                           attrs=["objectGUID"]);
1280         ldb.rename("cn=parentguidtest,cn=users," + self.base_dn,
1281                    "cn=parentguidtest,cn=testotherusers," + self.base_dn);
1282         res2 = ldb.search(base="cn=parentguidtest,cn=testotherusers," + self.base_dn,
1283                           scope=SCOPE_BASE,
1284                           attrs=["parentGUID"]);
1285         self.assertEquals(res1[0]["objectGUID"], res2[0]["parentGUID"]);
1286
1287         self.delete_force(self.ldb, "cn=parentguidtest,cn=testotherusers," + self.base_dn)
1288         self.delete_force(self.ldb, "cn=testotherusers," + self.base_dn)
1289
1290     def test_groupType_int32(self):
1291         """Test groupType (int32) behaviour (should appear to be casted to a 32 bit signed integer before comparsion)"""
1292         print "Testing groupType (int32) behaviour\n"
1293
1294         res1 = ldb.search(base=self.base_dn, scope=SCOPE_SUBTREE,
1295                           attrs=["groupType"], expression="groupType=2147483653");
1296
1297         res2 = ldb.search(base=self.base_dn, scope=SCOPE_SUBTREE,
1298                           attrs=["groupType"], expression="groupType=-2147483643");
1299
1300         self.assertEquals(len(res1), len(res2))
1301
1302         self.assertTrue(res1.count > 0)
1303
1304         self.assertEquals(res1[0]["groupType"][0], "-2147483643")
1305
1306     def test_linked_attributes(self):
1307         """This tests the linked attribute behaviour"""
1308         print "Testing linked attribute behaviour\n"
1309
1310         ldb.add({
1311             "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
1312             "objectclass": "group"})
1313
1314         # This should not work since "memberOf" is linked to "member"
1315         try:
1316             ldb.add({
1317                 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
1318                 "objectclass": ["user", "person"],
1319                 "memberOf": "cn=ldaptestgroup,cn=users," + self.base_dn})
1320         except LdbError, (num, _):
1321             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1322
1323         ldb.add({
1324             "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
1325             "objectclass": ["user", "person"]})
1326
1327         m = Message()
1328         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1329         m["memberOf"] = MessageElement("cn=ldaptestgroup,cn=users," + self.base_dn,
1330           FLAG_MOD_ADD, "memberOf")
1331         try:
1332             ldb.modify(m)
1333             self.fail()
1334         except LdbError, (num, _):
1335             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1336
1337         m = Message()
1338         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1339         m["member"] = MessageElement("cn=ldaptestuser,cn=users," + self.base_dn,
1340           FLAG_MOD_ADD, "member")
1341         ldb.modify(m)
1342
1343         m = Message()
1344         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1345         m["memberOf"] = MessageElement("cn=ldaptestgroup,cn=users," + self.base_dn,
1346           FLAG_MOD_REPLACE, "memberOf")
1347         try:
1348             ldb.modify(m)
1349             self.fail()
1350         except LdbError, (num, _):
1351             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1352
1353         m = Message()
1354         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1355         m["memberOf"] = MessageElement("cn=ldaptestgroup,cn=users," + self.base_dn,
1356           FLAG_MOD_DELETE, "memberOf")
1357         try:
1358             ldb.modify(m)
1359             self.fail()
1360         except LdbError, (num, _):
1361             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1362
1363         m = Message()
1364         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1365         m["member"] = MessageElement("cn=ldaptestuser,cn=users," + self.base_dn,
1366           FLAG_MOD_DELETE, "member")
1367         ldb.modify(m)
1368
1369         # This should yield no results since the member attribute for
1370         # "ldaptestuser" should have been deleted
1371         res1 = ldb.search("cn=ldaptestgroup, cn=users," + self.base_dn,
1372                           scope=SCOPE_BASE,
1373                           expression="(member=cn=ldaptestuser,cn=users," + self.base_dn + ")",
1374                           attrs=[])
1375         self.assertTrue(len(res1) == 0)
1376
1377         self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1378
1379         ldb.add({
1380             "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
1381             "objectclass": "group",
1382             "member": "cn=ldaptestuser,cn=users," + self.base_dn})
1383
1384         self.delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1385
1386         # Make sure that the "member" attribute for "ldaptestuser" has been
1387         # removed
1388         res = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
1389                           scope=SCOPE_BASE, attrs=["member"])
1390         self.assertTrue(len(res) == 1)
1391         self.assertFalse("member" in res[0])
1392
1393         self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1394
1395     def test_wkguid(self):
1396         """Test Well known GUID behaviours (including DN+Binary)"""
1397         print "Test Well known GUID behaviours (including DN+Binary)"""
1398
1399         res = self.ldb.search(base=("<WKGUID=ab1d30f3768811d1aded00c04fd8d5cd,%s>" % self.base_dn), scope=SCOPE_BASE, attrs=[])
1400         self.assertEquals(len(res), 1)
1401
1402         res2 = self.ldb.search(scope=SCOPE_BASE, attrs=["wellKnownObjects"], expression=("wellKnownObjects=B:32:ab1d30f3768811d1aded00c04fd8d5cd:%s" % res[0].dn))
1403         self.assertEquals(len(res2), 1)
1404
1405         # Prove that the matching rule is over the whole DN+Binary
1406         res2 = self.ldb.search(scope=SCOPE_BASE, attrs=["wellKnownObjects"], expression=("wellKnownObjects=B:32:ab1d30f3768811d1aded00c04fd8d5cd"))
1407         self.assertEquals(len(res2), 0)
1408         # Prove that the matching rule is over the whole DN+Binary
1409         res2 = self.ldb.search(scope=SCOPE_BASE, attrs=["wellKnownObjects"], expression=("wellKnownObjects=%s") % res[0].dn)
1410         self.assertEquals(len(res2), 0)
1411
1412     def test_subschemasubentry(self):
1413         """Test subSchemaSubEntry appears when requested, but not when not requested"""
1414         print "Test subSchemaSubEntry"""
1415
1416         res = self.ldb.search(base=self.base_dn, scope=SCOPE_BASE, attrs=["subSchemaSubEntry"])
1417         self.assertEquals(len(res), 1)
1418         self.assertEquals(res[0]["subSchemaSubEntry"][0], "CN=Aggregate,"+self.schema_dn)
1419
1420         res = self.ldb.search(base=self.base_dn, scope=SCOPE_BASE, attrs=["*"])
1421         self.assertEquals(len(res), 1)
1422         self.assertTrue("subScheamSubEntry" not in res[0])
1423
1424     def test_all(self):
1425         """Basic tests"""
1426
1427         print "Testing user add"
1428
1429         ldb.add({
1430             "dn": "cn=ldaptestuser,cn=uSers," + self.base_dn,
1431             "objectclass": ["user", "person"],
1432             "cN": "LDAPtestUSER",
1433             "givenname": "ldap",
1434             "sn": "testy"})
1435
1436         ldb.add({
1437             "dn": "cn=ldaptestgroup,cn=uSers," + self.base_dn,
1438             "objectclass": "group",
1439             "member": "cn=ldaptestuser,cn=useRs," + self.base_dn})
1440
1441         ldb.add({
1442             "dn": "cn=ldaptestcomputer,cn=computers," + self.base_dn,
1443             "objectclass": "computer",
1444             "cN": "LDAPtestCOMPUTER"})
1445
1446         ldb.add({"dn": "cn=ldaptest2computer,cn=computers," + self.base_dn,
1447             "objectClass": "computer",
1448             "cn": "LDAPtest2COMPUTER",
1449             "userAccountControl": str(UF_WORKSTATION_TRUST_ACCOUNT),
1450             "displayname": "ldap testy"})
1451
1452         try:
1453             ldb.add({"dn": "cn=ldaptestcomputer3,cn=computers," + self.base_dn,
1454                      "objectClass": "computer",
1455                      "cn": "LDAPtest2COMPUTER"
1456                      })
1457             self.fail()
1458         except LdbError, (num, _):
1459             self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
1460
1461         try:
1462             ldb.add({"dn": "cn=ldaptestcomputer3,cn=computers," + self.base_dn,
1463                      "objectClass": "computer",
1464                      "cn": "ldaptestcomputer3",
1465                      "sAMAccountType": str(ATYPE_NORMAL_ACCOUNT)
1466                 })
1467             self.fail()
1468         except LdbError, (num, _):
1469             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1470
1471         ldb.add({"dn": "cn=ldaptestcomputer3,cn=computers," + self.base_dn,
1472                  "objectClass": "computer",
1473                  "cn": "LDAPtestCOMPUTER3"
1474                  })
1475
1476         print "Testing ldb.search for (&(cn=ldaptestcomputer3)(objectClass=user))";
1477         res = ldb.search(self.base_dn, expression="(&(cn=ldaptestcomputer3)(objectClass=user))");
1478         self.assertEquals(len(res), 1, "Found only %d for (&(cn=ldaptestcomputer3)(objectClass=user))" % len(res))
1479
1480         self.assertEquals(str(res[0].dn), ("CN=ldaptestcomputer3,CN=Computers," + self.base_dn));
1481         self.assertEquals(res[0]["cn"][0], "ldaptestcomputer3");
1482         self.assertEquals(res[0]["name"][0], "ldaptestcomputer3");
1483         self.assertEquals(res[0]["objectClass"][0], "top");
1484         self.assertEquals(res[0]["objectClass"][1], "person");
1485         self.assertEquals(res[0]["objectClass"][2], "organizationalPerson");
1486         self.assertEquals(res[0]["objectClass"][3], "user");
1487         self.assertEquals(res[0]["objectClass"][4], "computer");
1488         self.assertTrue("objectGUID" in res[0])
1489         self.assertTrue("whenCreated" in res[0])
1490         self.assertEquals(res[0]["objectCategory"][0], ("CN=Computer,CN=Schema,CN=Configuration," + self.base_dn));
1491         self.assertEquals(int(res[0]["primaryGroupID"][0]), 513);
1492         self.assertEquals(int(res[0]["sAMAccountType"][0]), ATYPE_NORMAL_ACCOUNT);
1493         self.assertEquals(int(res[0]["userAccountControl"][0]), UF_NORMAL_ACCOUNT | UF_PASSWD_NOTREQD | UF_ACCOUNTDISABLE);
1494
1495         self.delete_force(self.ldb, "cn=ldaptestcomputer3,cn=computers," + self.base_dn)
1496
1497         print "Testing attribute or value exists behaviour"
1498         try:
1499             ldb.modify_ldif("""
1500 dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """
1501 changetype: modify
1502 replace: servicePrincipalName
1503 servicePrincipalName: host/ldaptest2computer
1504 servicePrincipalName: host/ldaptest2computer
1505 servicePrincipalName: cifs/ldaptest2computer
1506 """)
1507             self.fail()
1508         except LdbError, (num, msg):
1509             self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
1510
1511         ldb.modify_ldif("""
1512 dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """
1513 changetype: modify
1514 replace: servicePrincipalName
1515 servicePrincipalName: host/ldaptest2computer
1516 servicePrincipalName: cifs/ldaptest2computer
1517 """)
1518         try:
1519             ldb.modify_ldif("""
1520 dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """
1521 changetype: modify
1522 add: servicePrincipalName
1523 servicePrincipalName: host/ldaptest2computer
1524 """)
1525             self.fail()
1526         except LdbError, (num, msg):
1527             self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
1528
1529         print "Testing ranged results"
1530         ldb.modify_ldif("""
1531 dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """
1532 changetype: modify
1533 replace: servicePrincipalName
1534 """)
1535
1536         ldb.modify_ldif("""
1537 dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """
1538 changetype: modify
1539 add: servicePrincipalName
1540 servicePrincipalName: host/ldaptest2computer0
1541 servicePrincipalName: host/ldaptest2computer1
1542 servicePrincipalName: host/ldaptest2computer2
1543 servicePrincipalName: host/ldaptest2computer3
1544 servicePrincipalName: host/ldaptest2computer4
1545 servicePrincipalName: host/ldaptest2computer5
1546 servicePrincipalName: host/ldaptest2computer6
1547 servicePrincipalName: host/ldaptest2computer7
1548 servicePrincipalName: host/ldaptest2computer8
1549 servicePrincipalName: host/ldaptest2computer9
1550 servicePrincipalName: host/ldaptest2computer10
1551 servicePrincipalName: host/ldaptest2computer11
1552 servicePrincipalName: host/ldaptest2computer12
1553 servicePrincipalName: host/ldaptest2computer13
1554 servicePrincipalName: host/ldaptest2computer14
1555 servicePrincipalName: host/ldaptest2computer15
1556 servicePrincipalName: host/ldaptest2computer16
1557 servicePrincipalName: host/ldaptest2computer17
1558 servicePrincipalName: host/ldaptest2computer18
1559 servicePrincipalName: host/ldaptest2computer19
1560 servicePrincipalName: host/ldaptest2computer20
1561 servicePrincipalName: host/ldaptest2computer21
1562 servicePrincipalName: host/ldaptest2computer22
1563 servicePrincipalName: host/ldaptest2computer23
1564 servicePrincipalName: host/ldaptest2computer24
1565 servicePrincipalName: host/ldaptest2computer25
1566 servicePrincipalName: host/ldaptest2computer26
1567 servicePrincipalName: host/ldaptest2computer27
1568 servicePrincipalName: host/ldaptest2computer28
1569 servicePrincipalName: host/ldaptest2computer29
1570 """)
1571
1572         res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE,
1573                          attrs=["servicePrincipalName;range=0-*"])
1574         self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
1575         #print len(res[0]["servicePrincipalName;range=0-*"])
1576         self.assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30)
1577
1578         res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-19"])
1579         self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
1580             # print res[0]["servicePrincipalName;range=0-19"].length
1581         self.assertEquals(len(res[0]["servicePrincipalName;range=0-19"]), 20)
1582
1583
1584         res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-30"])
1585         self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
1586         self.assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30)
1587
1588         res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-40"])
1589         self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
1590         self.assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30)
1591
1592         res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=30-40"])
1593         self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
1594         self.assertEquals(len(res[0]["servicePrincipalName;range=30-*"]), 0)
1595
1596
1597         res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=10-40"])
1598         self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
1599         self.assertEquals(len(res[0]["servicePrincipalName;range=10-*"]), 20)
1600         # pos_11 = res[0]["servicePrincipalName;range=10-*"][18]
1601
1602         res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=11-40"])
1603         self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
1604         self.assertEquals(len(res[0]["servicePrincipalName;range=11-*"]), 19)
1605             # print res[0]["servicePrincipalName;range=11-*"][18]
1606             # print pos_11
1607             # self.assertEquals((res[0]["servicePrincipalName;range=11-*"][18]), pos_11)
1608
1609         res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=11-15"])
1610         self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
1611         self.assertEquals(len(res[0]["servicePrincipalName;range=11-15"]), 5)
1612             # self.assertEquals(res[0]["servicePrincipalName;range=11-15"][4], pos_11)
1613
1614         res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName"])
1615         self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
1616             # print res[0]["servicePrincipalName"][18]
1617             # print pos_11
1618         self.assertEquals(len(res[0]["servicePrincipalName"]), 30)
1619             # self.assertEquals(res[0]["servicePrincipalName"][18], pos_11)
1620
1621         self.delete_force(self.ldb, "cn=ldaptestuser2,cn=users," + self.base_dn)
1622         ldb.add({
1623             "dn": "cn=ldaptestuser2,cn=useRs," + self.base_dn,
1624             "objectClass": ["person", "user"],
1625             "cn": "LDAPtestUSER2",
1626             "givenname": "testy",
1627             "sn": "ldap user2"})
1628
1629         print "Testing Ambigious Name Resolution"
1630         # Testing ldb.search for (&(anr=ldap testy)(objectClass=user))
1631         res = ldb.search(expression="(&(anr=ldap testy)(objectClass=user))")
1632         self.assertEquals(len(res), 3, "Found only %d of 3 for (&(anr=ldap testy)(objectClass=user))" % len(res))
1633
1634         # Testing ldb.search for (&(anr=testy ldap)(objectClass=user))
1635         res = ldb.search(expression="(&(anr=testy ldap)(objectClass=user))")
1636         self.assertEquals(len(res), 2, "Found only %d of 2 for (&(anr=testy ldap)(objectClass=user))" % len(res))
1637
1638         # Testing ldb.search for (&(anr=ldap)(objectClass=user))
1639         res = ldb.search(expression="(&(anr=ldap)(objectClass=user))")
1640         self.assertEquals(len(res), 4, "Found only %d of 4 for (&(anr=ldap)(objectClass=user))" % len(res))
1641
1642         # Testing ldb.search for (&(anr==ldap)(objectClass=user))
1643         res = ldb.search(expression="(&(anr==ldap)(objectClass=user))")
1644         self.assertEquals(len(res), 1, "Could not find (&(anr==ldap)(objectClass=user)). Found only %d for (&(anr=ldap)(objectClass=user))" % len(res))
1645
1646         self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn))
1647         self.assertEquals(res[0]["cn"][0], "ldaptestuser")
1648         self.assertEquals(str(res[0]["name"]), "ldaptestuser")
1649
1650         # Testing ldb.search for (&(anr=testy)(objectClass=user))
1651         res = ldb.search(expression="(&(anr=testy)(objectClass=user))")
1652         self.assertEquals(len(res), 2, "Found only %d for (&(anr=testy)(objectClass=user))" % len(res))
1653
1654         # Testing ldb.search for (&(anr=testy ldap)(objectClass=user))
1655         res = ldb.search(expression="(&(anr=testy ldap)(objectClass=user))")
1656         self.assertEquals(len(res), 2, "Found only %d for (&(anr=testy ldap)(objectClass=user))" % len(res))
1657
1658         # Testing ldb.search for (&(anr==testy ldap)(objectClass=user))
1659 # this test disabled for the moment, as anr with == tests are not understood
1660 #        res = ldb.search(expression="(&(anr==testy ldap)(objectClass=user))")
1661 #        self.assertEquals(len(res), 1, "Found only %d for (&(anr==testy ldap)(objectClass=user))" % len(res))
1662
1663 #        self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn))
1664 #        self.assertEquals(res[0]["cn"][0], "ldaptestuser")
1665 #        self.assertEquals(res[0]["name"][0], "ldaptestuser")
1666
1667         # Testing ldb.search for (&(anr==testy ldap)(objectClass=user))
1668 #        res = ldb.search(expression="(&(anr==testy ldap)(objectClass=user))")
1669 #        self.assertEquals(len(res), 1, "Could not find (&(anr==testy ldap)(objectClass=user))")
1670
1671 #        self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn))
1672 #        self.assertEquals(res[0]["cn"][0], "ldaptestuser")
1673 #        self.assertEquals(res[0]["name"][0], "ldaptestuser")
1674
1675         # Testing ldb.search for (&(anr=testy ldap user)(objectClass=user))
1676         res = ldb.search(expression="(&(anr=testy ldap user)(objectClass=user))")
1677         self.assertEquals(len(res), 1, "Could not find (&(anr=testy ldap user)(objectClass=user))")
1678
1679         self.assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
1680         self.assertEquals(str(res[0]["cn"]), "ldaptestuser2")
1681         self.assertEquals(str(res[0]["name"]), "ldaptestuser2")
1682
1683         # Testing ldb.search for (&(anr==testy ldap user2)(objectClass=user))
1684 #        res = ldb.search(expression="(&(anr==testy ldap user2)(objectClass=user))")
1685 #        self.assertEquals(len(res), 1, "Could not find (&(anr==testy ldap user2)(objectClass=user))")
1686
1687         self.assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
1688         self.assertEquals(str(res[0]["cn"]), "ldaptestuser2")
1689         self.assertEquals(str(res[0]["name"]), "ldaptestuser2")
1690
1691         # Testing ldb.search for (&(anr==ldap user2)(objectClass=user))
1692 #        res = ldb.search(expression="(&(anr==ldap user2)(objectClass=user))")
1693 #        self.assertEquals(len(res), 1, "Could not find (&(anr==ldap user2)(objectClass=user))")
1694
1695         self.assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
1696         self.assertEquals(str(res[0]["cn"]), "ldaptestuser2")
1697         self.assertEquals(str(res[0]["name"]), "ldaptestuser2")
1698
1699         # Testing ldb.search for (&(anr==not ldap user2)(objectClass=user))
1700 #        res = ldb.search(expression="(&(anr==not ldap user2)(objectClass=user))")
1701 #        self.assertEquals(len(res), 0, "Must not find (&(anr==not ldap user2)(objectClass=user))")
1702
1703         # Testing ldb.search for (&(anr=not ldap user2)(objectClass=user))
1704         res = ldb.search(expression="(&(anr=not ldap user2)(objectClass=user))")
1705         self.assertEquals(len(res), 0, "Must not find (&(anr=not ldap user2)(objectClass=user))")
1706
1707         # Testing ldb.search for (&(anr="testy ldap")(objectClass=user)) (ie, with quotes)
1708 #        res = ldb.search(expression="(&(anr==\"testy ldap\")(objectClass=user))")
1709 #        self.assertEquals(len(res), 0, "Found (&(anr==\"testy ldap\")(objectClass=user))")
1710
1711         print "Testing Renames"
1712
1713         attrs = ["objectGUID", "objectSid"]
1714         print "Testing ldb.search for (&(cn=ldaptestUSer2)(objectClass=user))"
1715         res_user = ldb.search(self.base_dn, expression="(&(cn=ldaptestUSer2)(objectClass=user))", scope=SCOPE_SUBTREE, attrs=attrs)
1716         self.assertEquals(len(res_user), 1, "Could not find (&(cn=ldaptestUSer2)(objectClass=user))")
1717
1718         # Check rename works with extended/alternate DN forms
1719         ldb.rename("<SID=" + ldb.schema_format_value("objectSID", res_user[0]["objectSID"][0]) + ">" , "cn=ldaptestUSER3,cn=users," + self.base_dn)
1720
1721         print "Testing ldb.search for (&(cn=ldaptestuser3)(objectClass=user))"
1722         res = ldb.search(expression="(&(cn=ldaptestuser3)(objectClass=user))")
1723         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser3)(objectClass=user))")
1724
1725         self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
1726         self.assertEquals(str(res[0]["cn"]), "ldaptestUSER3")
1727         self.assertEquals(str(res[0]["name"]), "ldaptestUSER3")
1728
1729          #"Testing ldb.search for (&(&(cn=ldaptestuser3)(userAccountControl=*))(objectClass=user))"
1730         res = ldb.search(expression="(&(&(cn=ldaptestuser3)(userAccountControl=*))(objectClass=user))")
1731         self.assertEquals(len(res), 1, "(&(&(cn=ldaptestuser3)(userAccountControl=*))(objectClass=user))")
1732
1733         self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
1734         self.assertEquals(str(res[0]["cn"]), "ldaptestUSER3")
1735         self.assertEquals(str(res[0]["name"]), "ldaptestUSER3")
1736
1737          #"Testing ldb.search for (&(&(cn=ldaptestuser3)(userAccountControl=546))(objectClass=user))"
1738         res = ldb.search(expression="(&(&(cn=ldaptestuser3)(userAccountControl=546))(objectClass=user))")
1739         self.assertEquals(len(res), 1, "(&(&(cn=ldaptestuser3)(userAccountControl=546))(objectClass=user))")
1740
1741         self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
1742         self.assertEquals(str(res[0]["cn"]), "ldaptestUSER3")
1743         self.assertEquals(str(res[0]["name"]), "ldaptestUSER3")
1744
1745          #"Testing ldb.search for (&(&(cn=ldaptestuser3)(userAccountControl=547))(objectClass=user))"
1746         res = ldb.search(expression="(&(&(cn=ldaptestuser3)(userAccountControl=547))(objectClass=user))")
1747         self.assertEquals(len(res), 0, "(&(&(cn=ldaptestuser3)(userAccountControl=547))(objectClass=user))")
1748
1749         # This is a Samba special, and does not exist in real AD
1750         #    print "Testing ldb.search for (dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")"
1751         #    res = ldb.search("(dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")")
1752         #    if (res.error != 0 || len(res) != 1) {
1753         #        print "Could not find (dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")"
1754         #        self.assertEquals(len(res), 1)
1755         #    }
1756         #    self.assertEquals(res[0].dn, ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
1757         #    self.assertEquals(res[0].cn, "ldaptestUSER3")
1758         #    self.assertEquals(res[0].name, "ldaptestUSER3")
1759
1760         print "Testing ldb.search for (distinguishedName=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")"
1761         res = ldb.search(expression="(distinguishedName=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")")
1762         self.assertEquals(len(res), 1, "Could not find (dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")")
1763         self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
1764         self.assertEquals(str(res[0]["cn"]), "ldaptestUSER3")
1765         self.assertEquals(str(res[0]["name"]), "ldaptestUSER3")
1766
1767         # ensure we cannot add it again
1768         try:
1769             ldb.add({"dn": "cn=ldaptestuser3,cn=userS," + self.base_dn,
1770                       "objectClass": ["person", "user"],
1771                       "cn": "LDAPtestUSER3"})
1772             self.fail()
1773         except LdbError, (num, _):
1774             self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
1775
1776         # rename back
1777         ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser2,cn=users," + self.base_dn)
1778
1779         # ensure we cannot rename it twice
1780         try:
1781             ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn,
1782                        "cn=ldaptestuser2,cn=users," + self.base_dn)
1783             self.fail()
1784         except LdbError, (num, _):
1785             self.assertEquals(num, ERR_NO_SUCH_OBJECT)
1786
1787         # ensure can now use that name
1788         ldb.add({"dn": "cn=ldaptestuser3,cn=users," + self.base_dn,
1789                       "objectClass": ["person", "user"],
1790                       "cn": "LDAPtestUSER3"})
1791
1792         # ensure we now cannot rename
1793         try:
1794             ldb.rename("cn=ldaptestuser2,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=users," + self.base_dn)
1795             self.fail()
1796         except LdbError, (num, _):
1797             self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
1798         try:
1799             ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=configuration," + self.base_dn)
1800             self.fail()
1801         except LdbError, (num, _):
1802             self.assertTrue(num in (71, 64))
1803
1804         ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser5,cn=users," + self.base_dn)
1805
1806         ldb.delete("cn=ldaptestuser5,cn=users," + self.base_dn)
1807
1808         self.delete_force(ldb, "cn=ldaptestgroup2,cn=users," + self.base_dn)
1809
1810         ldb.rename("cn=ldaptestgroup,cn=users," + self.base_dn, "cn=ldaptestgroup2,cn=users," + self.base_dn)
1811
1812         print "Testing subtree renames"
1813
1814         ldb.add({"dn": "cn=ldaptestcontainer," + self.base_dn,
1815                  "objectClass": "container"})
1816
1817         ldb.add({"dn": "CN=ldaptestuser4,CN=ldaptestcontainer," + self.base_dn,
1818                  "objectClass": ["person", "user"],
1819                  "cn": "LDAPtestUSER4"})
1820
1821         ldb.modify_ldif("""
1822 dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
1823 changetype: modify
1824 add: member
1825 member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """
1826 member: cn=ldaptestcomputer,cn=computers,""" + self.base_dn + """
1827 member: cn=ldaptestuser2,cn=users,""" + self.base_dn + """
1828 """)
1829
1830         print "Testing ldb.rename of cn=ldaptestcontainer," + self.base_dn + " to cn=ldaptestcontainer2," + self.base_dn
1831         ldb.rename("CN=ldaptestcontainer," + self.base_dn, "CN=ldaptestcontainer2," + self.base_dn)
1832
1833         print "Testing ldb.search for (&(cn=ldaptestuser4)(objectClass=user))"
1834         res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))")
1835         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser4)(objectClass=user))")
1836
1837         print "Testing subtree ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + self.base_dn
1838         try:
1839             res = ldb.search("cn=ldaptestcontainer," + self.base_dn,
1840                     expression="(&(cn=ldaptestuser4)(objectClass=user))",
1841                     scope=SCOPE_SUBTREE)
1842             self.fail(res)
1843         except LdbError, (num, _):
1844             self.assertEquals(num, ERR_NO_SUCH_OBJECT)
1845
1846         print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + self.base_dn
1847         try:
1848             res = ldb.search("cn=ldaptestcontainer," + self.base_dn,
1849                     expression="(&(cn=ldaptestuser4)(objectClass=user))", scope=SCOPE_ONELEVEL)
1850             self.fail()
1851         except LdbError, (num, _):
1852             self.assertEquals(num, ERR_NO_SUCH_OBJECT)
1853
1854         print "Testing ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in renamed container"
1855         res = ldb.search("cn=ldaptestcontainer2," + self.base_dn, expression="(&(cn=ldaptestuser4)(objectClass=user))", scope=SCOPE_SUBTREE)
1856         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser4)(objectClass=user)) under cn=ldaptestcontainer2," + self.base_dn)
1857
1858         self.assertEquals(str(res[0].dn), ("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn))
1859         self.assertEquals(res[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
1860
1861         time.sleep(4)
1862
1863         print "Testing ldb.search for (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group)) to check subtree renames and linked attributes"
1864         res = ldb.search(self.base_dn, expression="(&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group))", scope=SCOPE_SUBTREE)
1865         self.assertEquals(len(res), 1, "Could not find (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group)), perhaps linked attributes are not consistant with subtree renames?")
1866
1867         print "Testing ldb.rename (into itself) of cn=ldaptestcontainer2," + self.base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer2," + self.base_dn
1868         try:
1869             ldb.rename("cn=ldaptestcontainer2," + self.base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer2," + self.base_dn)
1870             self.fail()
1871         except LdbError, (num, _):
1872             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1873
1874         print "Testing ldb.rename (into non-existent container) of cn=ldaptestcontainer2," + self.base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer3," + self.base_dn
1875         try:
1876             ldb.rename("cn=ldaptestcontainer2," + self.base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer3," + self.base_dn)
1877             self.fail()
1878         except LdbError, (num, _):
1879             self.assertTrue(num in (ERR_UNWILLING_TO_PERFORM, ERR_OTHER))
1880
1881         print "Testing delete (should fail, not a leaf node) of renamed cn=ldaptestcontainer2," + self.base_dn
1882         try:
1883             ldb.delete("cn=ldaptestcontainer2," + self.base_dn)
1884             self.fail()
1885         except LdbError, (num, _):
1886             self.assertEquals(num, ERR_NOT_ALLOWED_ON_NON_LEAF)
1887
1888         print "Testing base ldb.search for CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn
1889         res = ldb.search(expression="(objectclass=*)", base=("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn), scope=SCOPE_BASE)
1890         self.assertEquals(len(res), 1)
1891         res = ldb.search(expression="(cn=ldaptestuser40)", base=("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn), scope=SCOPE_BASE)
1892         self.assertEquals(len(res), 0)
1893
1894         print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in cn=ldaptestcontainer2," + self.base_dn
1895         res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))", base=("cn=ldaptestcontainer2," + self.base_dn), scope=SCOPE_ONELEVEL)
1896         # FIXME: self.assertEquals(len(res), 0)
1897
1898         print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in cn=ldaptestcontainer2," + self.base_dn
1899         res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))", base=("cn=ldaptestcontainer2," + self.base_dn), scope=SCOPE_SUBTREE)
1900         # FIXME: self.assertEquals(len(res), 0)
1901
1902         print "Testing delete of subtree renamed "+("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn)
1903         ldb.delete(("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn))
1904         print "Testing delete of renamed cn=ldaptestcontainer2," + self.base_dn
1905         ldb.delete("cn=ldaptestcontainer2," + self.base_dn)
1906
1907         ldb.add({"dn": "cn=ldaptestutf8user èùéìòà,cn=users," + self.base_dn, "objectClass": "user"})
1908
1909         ldb.add({"dn": "cn=ldaptestutf8user2  èùéìòà,cn=users," + self.base_dn, "objectClass": "user"})
1910
1911         print "Testing ldb.search for (&(cn=ldaptestuser)(objectClass=user))"
1912         res = ldb.search(expression="(&(cn=ldaptestuser)(objectClass=user))")
1913         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser)(objectClass=user))")
1914
1915         self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn))
1916         self.assertEquals(str(res[0]["cn"]), "ldaptestuser")
1917         self.assertEquals(str(res[0]["name"]), "ldaptestuser")
1918         self.assertEquals(set(res[0]["objectClass"]), set(["top", "person", "organizationalPerson", "user"]))
1919         self.assertTrue("objectGUID" in res[0])
1920         self.assertTrue("whenCreated" in res[0])
1921         self.assertEquals(str(res[0]["objectCategory"]), ("CN=Person,CN=Schema,CN=Configuration," + self.base_dn))
1922         self.assertEquals(int(res[0]["sAMAccountType"][0]), ATYPE_NORMAL_ACCOUNT)
1923         self.assertEquals(int(res[0]["userAccountControl"][0]), UF_NORMAL_ACCOUNT | UF_PASSWD_NOTREQD | UF_ACCOUNTDISABLE)
1924         self.assertEquals(res[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
1925         self.assertEquals(len(res[0]["memberOf"]), 1)
1926
1927         print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + self.base_dn + "))"
1928         res2 = ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + self.base_dn + "))")
1929         self.assertEquals(len(res2), 1, "Could not find (&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + self.base_dn + "))")
1930
1931         self.assertEquals(res[0].dn, res2[0].dn)
1932
1933         print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon))"
1934         res3 = ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=PerSon))")
1935         self.assertEquals(len(res3), 1, "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)): matched %d" % len(res3))
1936
1937         self.assertEquals(res[0].dn, res3[0].dn)
1938
1939         if gc_ldb is not None:
1940             print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog"
1941             res3gc = gc_ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=PerSon))")
1942             self.assertEquals(len(res3gc), 1)
1943
1944             self.assertEquals(res[0].dn, res3gc[0].dn)
1945
1946         print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon)) in with 'phantom root' control"
1947
1948         if gc_ldb is not None:
1949             res3control = gc_ldb.search(self.base_dn, expression="(&(cn=ldaptestuser)(objectCategory=PerSon))", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:2"])
1950             self.assertEquals(len(res3control), 1, "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog")
1951
1952             self.assertEquals(res[0].dn, res3control[0].dn)
1953
1954         ldb.delete(res[0].dn)
1955
1956         print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectClass=user))"
1957         res = ldb.search(expression="(&(cn=ldaptestcomputer)(objectClass=user))")
1958         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser)(objectClass=user))")
1959
1960         self.assertEquals(str(res[0].dn), ("CN=ldaptestcomputer,CN=Computers," + self.base_dn))
1961         self.assertEquals(str(res[0]["cn"]), "ldaptestcomputer")
1962         self.assertEquals(str(res[0]["name"]), "ldaptestcomputer")
1963         self.assertEquals(set(res[0]["objectClass"]), set(["top", "person", "organizationalPerson", "user", "computer"]))
1964         self.assertTrue("objectGUID" in res[0])
1965         self.assertTrue("whenCreated" in res[0])
1966         self.assertEquals(str(res[0]["objectCategory"]), ("CN=Computer,CN=Schema,CN=Configuration," + self.base_dn))
1967         self.assertEquals(int(res[0]["primaryGroupID"][0]), 513)
1968         self.assertEquals(int(res[0]["sAMAccountType"][0]), ATYPE_NORMAL_ACCOUNT)
1969         self.assertEquals(int(res[0]["userAccountControl"][0]), UF_NORMAL_ACCOUNT | UF_PASSWD_NOTREQD | UF_ACCOUNTDISABLE)
1970         self.assertEquals(res[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
1971         self.assertEquals(len(res[0]["memberOf"]), 1)
1972
1973         print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + self.base_dn + "))"
1974         res2 = ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + self.base_dn + "))")
1975         self.assertEquals(len(res2), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + self.base_dn + "))")
1976
1977         self.assertEquals(res[0].dn, res2[0].dn)
1978
1979         if gc_ldb is not None:
1980             print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + self.base_dn + ")) in Global Catlog"
1981             res2gc = gc_ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + self.base_dn + "))")
1982             self.assertEquals(len(res2gc), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + self.base_dn + ")) in Global Catlog")
1983
1984             self.assertEquals(res[0].dn, res2gc[0].dn)
1985
1986         print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER))"
1987         res3 = ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=compuTER))")
1988         self.assertEquals(len(res3), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER))")
1989
1990         self.assertEquals(res[0].dn, res3[0].dn)
1991
1992         if gc_ldb is not None:
1993             print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog"
1994             res3gc = gc_ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=compuTER))")
1995             self.assertEquals(len(res3gc), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog")
1996
1997             self.assertEquals(res[0].dn, res3gc[0].dn)
1998
1999         print "Testing ldb.search for (&(cn=ldaptestcomp*r)(objectCategory=compuTER))"
2000         res4 = ldb.search(expression="(&(cn=ldaptestcomp*r)(objectCategory=compuTER))")
2001         self.assertEquals(len(res4), 1, "Could not find (&(cn=ldaptestcomp*r)(objectCategory=compuTER))")
2002
2003         self.assertEquals(res[0].dn, res4[0].dn)
2004
2005         print "Testing ldb.search for (&(cn=ldaptestcomput*)(objectCategory=compuTER))"
2006         res5 = ldb.search(expression="(&(cn=ldaptestcomput*)(objectCategory=compuTER))")
2007         self.assertEquals(len(res5), 1, "Could not find (&(cn=ldaptestcomput*)(objectCategory=compuTER))")
2008
2009         self.assertEquals(res[0].dn, res5[0].dn)
2010
2011         print "Testing ldb.search for (&(cn=*daptestcomputer)(objectCategory=compuTER))"
2012         res6 = ldb.search(expression="(&(cn=*daptestcomputer)(objectCategory=compuTER))")
2013         self.assertEquals(len(res6), 1, "Could not find (&(cn=*daptestcomputer)(objectCategory=compuTER))")
2014
2015         self.assertEquals(res[0].dn, res6[0].dn)
2016
2017         ldb.delete("<GUID=" + ldb.schema_format_value("objectGUID", res[0]["objectGUID"][0]) + ">")
2018
2019         print "Testing ldb.search for (&(cn=ldaptest2computer)(objectClass=user))"
2020         res = ldb.search(expression="(&(cn=ldaptest2computer)(objectClass=user))")
2021         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptest2computer)(objectClass=user))")
2022
2023         self.assertEquals(str(res[0].dn), "CN=ldaptest2computer,CN=Computers," + self.base_dn)
2024         self.assertEquals(str(res[0]["cn"]), "ldaptest2computer")
2025         self.assertEquals(str(res[0]["name"]), "ldaptest2computer")
2026         self.assertEquals(list(res[0]["objectClass"]), ["top", "person", "organizationalPerson", "user", "computer"])
2027         self.assertTrue("objectGUID" in res[0])
2028         self.assertTrue("whenCreated" in res[0])
2029         self.assertEquals(res[0]["objectCategory"][0], "CN=Computer,CN=Schema,CN=Configuration," + self.base_dn)
2030         self.assertEquals(int(res[0]["sAMAccountType"][0]), ATYPE_WORKSTATION_TRUST)
2031         self.assertEquals(int(res[0]["userAccountControl"][0]), UF_WORKSTATION_TRUST_ACCOUNT)
2032
2033         ldb.delete("<SID=" + ldb.schema_format_value("objectSID", res[0]["objectSID"][0]) + ">")
2034
2035         attrs = ["cn", "name", "objectClass", "objectGUID", "objectSID", "whenCreated", "nTSecurityDescriptor", "memberOf", "allowedAttributes", "allowedAttributesEffective"]
2036         print "Testing ldb.search for (&(cn=ldaptestUSer2)(objectClass=user))"
2037         res_user = ldb.search(self.base_dn, expression="(&(cn=ldaptestUSer2)(objectClass=user))", scope=SCOPE_SUBTREE, attrs=attrs)
2038         self.assertEquals(len(res_user), 1, "Could not find (&(cn=ldaptestUSer2)(objectClass=user))")
2039
2040         self.assertEquals(str(res_user[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
2041         self.assertEquals(str(res_user[0]["cn"]), "ldaptestuser2")
2042         self.assertEquals(str(res_user[0]["name"]), "ldaptestuser2")
2043         self.assertEquals(list(res_user[0]["objectClass"]), ["top", "person", "organizationalPerson", "user"])
2044         self.assertTrue("objectSid" in res_user[0])
2045         self.assertTrue("objectGUID" in res_user[0])
2046         self.assertTrue("whenCreated" in res_user[0])
2047         self.assertTrue("nTSecurityDescriptor" in res_user[0])
2048         self.assertTrue("allowedAttributes" in res_user[0])
2049         self.assertTrue("allowedAttributesEffective" in res_user[0])
2050         self.assertEquals(res_user[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
2051
2052         ldaptestuser2_sid = res_user[0]["objectSid"][0]
2053         ldaptestuser2_guid = res_user[0]["objectGUID"][0]
2054
2055         attrs = ["cn", "name", "objectClass", "objectGUID", "objectSID", "whenCreated", "nTSecurityDescriptor", "member", "allowedAttributes", "allowedAttributesEffective"]
2056         print "Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group))"
2057         res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs)
2058         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))")
2059
2060         self.assertEquals(str(res[0].dn), ("CN=ldaptestgroup2,CN=Users," + self.base_dn))
2061         self.assertEquals(str(res[0]["cn"]), "ldaptestgroup2")
2062         self.assertEquals(str(res[0]["name"]), "ldaptestgroup2")
2063         self.assertEquals(list(res[0]["objectClass"]), ["top", "group"])
2064         self.assertTrue("objectGUID" in res[0])
2065         self.assertTrue("objectSid" in res[0])
2066         self.assertTrue("whenCreated" in res[0])
2067         self.assertTrue("nTSecurityDescriptor" in res[0])
2068         self.assertTrue("allowedAttributes" in res[0])
2069         self.assertTrue("allowedAttributesEffective" in res[0])
2070         memberUP = []
2071         for m in res[0]["member"]:
2072             memberUP.append(m.upper())
2073         self.assertTrue(("CN=ldaptestuser2,CN=Users," + self.base_dn).upper() in memberUP)
2074
2075         res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs, controls=["extended_dn:1:1"])
2076         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))")
2077
2078         print res[0]["member"]
2079         memberUP = []
2080         for m in res[0]["member"]:
2081             memberUP.append(m.upper())
2082         print ("<GUID=" + ldb.schema_format_value("objectGUID", ldaptestuser2_guid) + ">;<SID=" + ldb.schema_format_value("objectSid", ldaptestuser2_sid) + ">;CN=ldaptestuser2,CN=Users," + self.base_dn).upper()
2083
2084         self.assertTrue(("<GUID=" + ldb.schema_format_value("objectGUID", ldaptestuser2_guid) + ">;<SID=" + ldb.schema_format_value("objectSid", ldaptestuser2_sid) + ">;CN=ldaptestuser2,CN=Users," + self.base_dn).upper() in memberUP)
2085
2086         print "Quicktest for linked attributes"
2087         ldb.modify_ldif("""
2088 dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
2089 changetype: modify
2090 replace: member
2091 member: CN=ldaptestuser2,CN=Users,""" + self.base_dn + """
2092 member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
2093 """)
2094
2095         ldb.modify_ldif("""
2096 dn: <GUID=""" + ldb.schema_format_value("objectGUID", res[0]["objectGUID"][0]) + """>
2097 changetype: modify
2098 replace: member
2099 member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
2100 """)
2101
2102         ldb.modify_ldif("""
2103 dn: <SID=""" + ldb.schema_format_value("objectSid", res[0]["objectSid"][0]) + """>
2104 changetype: modify
2105 delete: member
2106 """)
2107
2108         ldb.modify_ldif("""
2109 dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
2110 changetype: modify
2111 add: member
2112 member: <GUID=""" + ldb.schema_format_value("objectGUID", res[0]["objectGUID"][0]) + """>
2113 member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
2114 """)
2115
2116         ldb.modify_ldif("""
2117 dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
2118 changetype: modify
2119 replace: member
2120 """)
2121
2122         ldb.modify_ldif("""
2123 dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
2124 changetype: modify
2125 add: member
2126 member: <SID=""" + ldb.schema_format_value("objectSid", res_user[0]["objectSid"][0]) + """>
2127 member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
2128 """)
2129
2130         ldb.modify_ldif("""
2131 dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
2132 changetype: modify
2133 delete: member
2134 member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
2135 """)
2136
2137         res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs)
2138         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))")
2139
2140         self.assertEquals(str(res[0].dn), ("CN=ldaptestgroup2,CN=Users," + self.base_dn))
2141         self.assertEquals(res[0]["member"][0], ("CN=ldaptestuser2,CN=Users," + self.base_dn))
2142         self.assertEquals(len(res[0]["member"]), 1)
2143
2144         ldb.delete(("CN=ldaptestuser2,CN=Users," + self.base_dn))
2145
2146         time.sleep(4)
2147
2148         attrs = ["cn", "name", "objectClass", "objectGUID", "whenCreated", "nTSecurityDescriptor", "member"]
2149         print "Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete"
2150         res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs)
2151         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete")
2152
2153         self.assertEquals(str(res[0].dn), ("CN=ldaptestgroup2,CN=Users," + self.base_dn))
2154         self.assertTrue("member" not in res[0])
2155
2156         print "Testing ldb.search for (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))"
2157 # TODO UTF8 users don't seem to work fully anymore
2158 #        res = ldb.search(expression="(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
2159         res = ldb.search(expression="(&(cn=ldaptestutf8user èùéìòà)(objectclass=user))")
2160         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
2161
2162         self.assertEquals(str(res[0].dn), ("CN=ldaptestutf8user èùéìòà,CN=Users," + self.base_dn))
2163         self.assertEquals(str(res[0]["cn"]), "ldaptestutf8user èùéìòà")
2164         self.assertEquals(str(res[0]["name"]), "ldaptestutf8user èùéìòà")
2165         self.assertEquals(list(res[0]["objectClass"]), ["top", "person", "organizationalPerson", "user"])
2166         self.assertTrue("objectGUID" in res[0])
2167         self.assertTrue("whenCreated" in res[0])
2168
2169         ldb.delete(res[0].dn)
2170
2171         print "Testing ldb.search for (&(cn=ldaptestutf8user2*)(objectClass=user))"
2172         res = ldb.search(expression="(&(cn=ldaptestutf8user2*)(objectClass=user))")
2173         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestutf8user2*)(objectClass=user))")
2174
2175         ldb.delete(res[0].dn)
2176
2177         ldb.delete(("CN=ldaptestgroup2,CN=Users," + self.base_dn))
2178
2179         print "Testing ldb.search for (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))"
2180 # TODO UTF8 users don't seem to work fully anymore
2181 #        res = ldb.search(expression="(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
2182 #        self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
2183
2184         print "Testing that we can't get at the configuration DN from the main search base"
2185         res = ldb.search(self.base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"])
2186         self.assertEquals(len(res), 0)
2187
2188         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"
2189         res = ldb.search(self.base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:2"])
2190         self.assertTrue(len(res) > 0)
2191
2192         if gc_ldb is not None:
2193             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"
2194
2195             res = gc_ldb.search(self.base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:0"])
2196             self.assertTrue(len(res) > 0)
2197
2198             print "Testing that we do find configuration elements in the global catlog"
2199             res = gc_ldb.search(self.base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"])
2200             self.assertTrue(len(res) > 0)
2201
2202             print "Testing that we do find configuration elements and user elements at the same time"
2203             res = gc_ldb.search(self.base_dn, expression="(|(objectClass=crossRef)(objectClass=person))", scope=SCOPE_SUBTREE, attrs=["cn"])
2204             self.assertTrue(len(res) > 0)
2205
2206             print "Testing that we do find configuration elements in the global catlog, with the configuration basedn"
2207             res = gc_ldb.search(self.configuration_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"])
2208             self.assertTrue(len(res) > 0)
2209
2210         print "Testing that we can get at the configuration DN on the main LDAP port"
2211         res = ldb.search(self.configuration_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"])
2212         self.assertTrue(len(res) > 0)
2213
2214         print "Testing objectCategory canonacolisation"
2215         res = ldb.search(self.configuration_dn, expression="objectCategory=ntDsDSA", scope=SCOPE_SUBTREE, attrs=["cn"])
2216         self.assertTrue(len(res) > 0, "Didn't find any records with objectCategory=ntDsDSA")
2217         self.assertTrue(len(res) != 0)
2218
2219         res = ldb.search(self.configuration_dn, expression="objectCategory=CN=ntDs-DSA," + self.schema_dn, scope=SCOPE_SUBTREE, attrs=["cn"])
2220         self.assertTrue(len(res) > 0, "Didn't find any records with objectCategory=CN=ntDs-DSA," + self.schema_dn)
2221         self.assertTrue(len(res) != 0)
2222
2223         print "Testing objectClass attribute order on "+ self.base_dn
2224         res = ldb.search(expression="objectClass=domain", base=self.base_dn,
2225                          scope=SCOPE_BASE, attrs=["objectClass"])
2226         self.assertEquals(len(res), 1)
2227
2228         self.assertEquals(list(res[0]["objectClass"]), ["top", "domain", "domainDNS"])
2229
2230     #  check enumeration
2231
2232         print "Testing ldb.search for objectCategory=person"
2233         res = ldb.search(self.base_dn, expression="objectCategory=person", scope=SCOPE_SUBTREE, attrs=["cn"])
2234         self.assertTrue(len(res) > 0)
2235
2236         print "Testing ldb.search for objectCategory=person with domain scope control"
2237         res = ldb.search(self.base_dn, expression="objectCategory=person", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"])
2238         self.assertTrue(len(res) > 0)
2239
2240         print "Testing ldb.search for objectCategory=user"
2241         res = ldb.search(self.base_dn, expression="objectCategory=user", scope=SCOPE_SUBTREE, attrs=["cn"])
2242         self.assertTrue(len(res) > 0)
2243
2244         print "Testing ldb.search for objectCategory=user with domain scope control"
2245         res = ldb.search(self.base_dn, expression="objectCategory=user", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"])
2246         self.assertTrue(len(res) > 0)
2247
2248         print "Testing ldb.search for objectCategory=group"
2249         res = ldb.search(self.base_dn, expression="objectCategory=group", scope=SCOPE_SUBTREE, attrs=["cn"])
2250         self.assertTrue(len(res) > 0)
2251
2252         print "Testing ldb.search for objectCategory=group with domain scope control"
2253         res = ldb.search(self.base_dn, expression="objectCategory=group", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"])
2254         self.assertTrue(len(res) > 0)
2255
2256         print "Testing creating a user with the posixAccount objectClass"
2257         self.ldb.add_ldif("""dn: cn=posixuser,CN=Users,%s
2258 objectClass: top
2259 objectClass: person
2260 objectClass: posixAccount
2261 objectClass: user
2262 objectClass: organizationalPerson
2263 cn: posixuser
2264 uid: posixuser
2265 sn: posixuser
2266 uidNumber: 10126
2267 gidNumber: 10126
2268 homeDirectory: /home/posixuser
2269 loginShell: /bin/bash
2270 gecos: Posix User;;;
2271 description: A POSIX user"""% (self.base_dn))
2272
2273         print "Testing removing the posixAccount objectClass from an existing user"
2274         self.ldb.modify_ldif("""dn: cn=posixuser,CN=Users,%s
2275 changetype: modify
2276 delete: objectClass
2277 objectClass: posixAccount"""% (self.base_dn))
2278
2279         print "Testing adding the posixAccount objectClass to an existing user"
2280         self.ldb.modify_ldif("""dn: cn=posixuser,CN=Users,%s
2281 changetype: modify
2282 add: objectClass
2283 objectClass: posixAccount"""% (self.base_dn))
2284
2285         self.delete_force(self.ldb, "cn=posixuser,cn=users," + self.base_dn)
2286         self.delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
2287         self.delete_force(self.ldb, "cn=ldaptestuser2,cn=users," + self.base_dn)
2288         self.delete_force(self.ldb, "cn=ldaptestuser3,cn=users," + self.base_dn)
2289         self.delete_force(self.ldb, "cn=ldaptestuser4,cn=ldaptestcontainer," + self.base_dn)
2290         self.delete_force(self.ldb, "cn=ldaptestuser4,cn=ldaptestcontainer2," + self.base_dn)
2291         self.delete_force(self.ldb, "cn=ldaptestuser5,cn=users," + self.base_dn)
2292         self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
2293         self.delete_force(self.ldb, "cn=ldaptestgroup2,cn=users," + self.base_dn)
2294         self.delete_force(self.ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
2295         self.delete_force(self.ldb, "cn=ldaptest2computer,cn=computers," + self.base_dn)
2296         self.delete_force(self.ldb, "cn=ldaptestcomputer3,cn=computers," + self.base_dn)
2297         self.delete_force(self.ldb, "cn=ldaptestutf8user èùéìòà,cn=users," + self.base_dn)
2298         self.delete_force(self.ldb, "cn=ldaptestutf8user2  èùéìòà,cn=users," + self.base_dn)
2299         self.delete_force(self.ldb, "cn=ldaptestcontainer," + self.base_dn)
2300         self.delete_force(self.ldb, "cn=ldaptestcontainer2," + self.base_dn)
2301
2302     def test_security_descriptor_add(self):
2303         """ Testing ldb.add_ldif() for nTSecurityDescriptor """
2304         user_name = "testdescriptoruser1"
2305         user_dn = "CN=%s,CN=Users,%s" % (user_name, self.base_dn)
2306         #
2307         # Test add_ldif() with SDDL security descriptor input
2308         #
2309         self.delete_force(self.ldb, user_dn)
2310         try:
2311             sddl = "O:DUG:DUD:PAI(A;;RPWP;;;AU)S:PAI"
2312             self.ldb.add_ldif("""
2313 dn: """ + user_dn + """
2314 objectclass: user
2315 sAMAccountName: """ + user_name + """
2316 nTSecurityDescriptor: """ + sddl)
2317             res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2318             desc = res[0]["nTSecurityDescriptor"][0]
2319             desc = ndr_unpack( security.descriptor, desc )
2320             desc_sddl = desc.as_sddl( self.domain_sid )
2321             self.assertEqual(desc_sddl, sddl)
2322         finally:
2323             self.delete_force(self.ldb, user_dn)
2324         #
2325         # Test add_ldif() with BASE64 security descriptor
2326         #
2327         try:
2328             sddl = "O:DUG:DUD:PAI(A;;RPWP;;;AU)S:PAI"
2329             desc = security.descriptor.from_sddl(sddl, self.domain_sid)
2330             desc_binary = ndr_pack(desc)
2331             desc_base64 = base64.b64encode(desc_binary)
2332             self.ldb.add_ldif("""
2333 dn: """ + user_dn + """
2334 objectclass: user
2335 sAMAccountName: """ + user_name + """
2336 nTSecurityDescriptor:: """ + desc_base64)
2337             res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2338             desc = res[0]["nTSecurityDescriptor"][0]
2339             desc = ndr_unpack(security.descriptor, desc)
2340             desc_sddl = desc.as_sddl(self.domain_sid)
2341             self.assertEqual(desc_sddl, sddl)
2342         finally:
2343             self.delete_force(self.ldb, user_dn)
2344
2345     def test_security_descriptor_add_neg(self):
2346         """Test add_ldif() with BASE64 security descriptor input using WRONG domain SID
2347             Negative test
2348         """
2349         user_name = "testdescriptoruser1"
2350         user_dn = "CN=%s,CN=Users,%s" % (user_name, self.base_dn)
2351         self.delete_force(self.ldb, user_dn)
2352         try:
2353             sddl = "O:DUG:DUD:PAI(A;;RPWP;;;AU)S:PAI"
2354             desc = security.descriptor.from_sddl(sddl, security.dom_sid('S-1-5-21'))
2355             desc_base64 = base64.b64encode( ndr_pack(desc) )
2356             self.ldb.add_ldif("""
2357 dn: """ + user_dn + """
2358 objectclass: user
2359 sAMAccountName: """ + user_name + """
2360 nTSecurityDescriptor:: """ + desc_base64)
2361             res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2362             self.assertTrue("nTSecurityDescriptor" in res[0])
2363         finally:
2364             self.delete_force(self.ldb, user_dn)
2365
2366     def test_security_descriptor_modify(self):
2367         """ Testing ldb.modify_ldif() for nTSecurityDescriptor """
2368         user_name = "testdescriptoruser2"
2369         user_dn = "CN=%s,CN=Users,%s" % (user_name, self.base_dn)
2370         #
2371         # Delete user object and test modify_ldif() with SDDL security descriptor input
2372         # Add ACE to the original descriptor test
2373         #
2374         try:
2375             self.delete_force(self.ldb, user_dn)
2376             self.ldb.add_ldif("""
2377 dn: """ + user_dn + """
2378 objectclass: user
2379 sAMAccountName: """ + user_name)
2380             # Modify descriptor
2381             res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2382             desc = res[0]["nTSecurityDescriptor"][0]
2383             desc = ndr_unpack(security.descriptor, desc)
2384             desc_sddl = desc.as_sddl(self.domain_sid)
2385             sddl = desc_sddl[:desc_sddl.find("(")] + "(A;;RPWP;;;AU)" + desc_sddl[desc_sddl.find("("):]
2386             mod = """
2387 dn: """ + user_dn + """
2388 changetype: modify
2389 replace: nTSecurityDescriptor
2390 nTSecurityDescriptor: """ + sddl
2391             self.ldb.modify_ldif(mod)
2392             # Read modified descriptor
2393             res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2394             desc = res[0]["nTSecurityDescriptor"][0]
2395             desc = ndr_unpack(security.descriptor, desc)
2396             desc_sddl = desc.as_sddl(self.domain_sid)
2397             self.assertEqual(desc_sddl, sddl)
2398         finally:
2399             self.delete_force(self.ldb, user_dn)
2400         #
2401         # Test modify_ldif() with SDDL security descriptor input
2402         # New desctiptor test
2403         #
2404         try:
2405             self.ldb.add_ldif("""
2406 dn: """ + user_dn + """
2407 objectclass: user
2408 sAMAccountName: """ + user_name)
2409             # Modify descriptor
2410             sddl = "O:DUG:DUD:PAI(A;;RPWP;;;AU)S:PAI"
2411             mod = """
2412 dn: """ + user_dn + """
2413 changetype: modify
2414 replace: nTSecurityDescriptor
2415 nTSecurityDescriptor: """ + sddl
2416             self.ldb.modify_ldif(mod)
2417             # Read modified descriptor
2418             res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2419             desc = res[0]["nTSecurityDescriptor"][0]
2420             desc = ndr_unpack(security.descriptor, desc)
2421             desc_sddl = desc.as_sddl(self.domain_sid)
2422             self.assertEqual(desc_sddl, sddl)
2423         finally:
2424             self.delete_force(self.ldb, user_dn)
2425         #
2426         # Test modify_ldif() with BASE64 security descriptor input
2427         # Add ACE to the original descriptor test
2428         #
2429         try:
2430             self.ldb.add_ldif("""
2431 dn: """ + user_dn + """
2432 objectclass: user
2433 sAMAccountName: """ + user_name)
2434             # Modify descriptor
2435             res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2436             desc = res[0]["nTSecurityDescriptor"][0]
2437             desc = ndr_unpack(security.descriptor, desc)
2438             desc_sddl = desc.as_sddl(self.domain_sid)
2439             sddl = desc_sddl[:desc_sddl.find("(")] + "(A;;RPWP;;;AU)" + desc_sddl[desc_sddl.find("("):]
2440             desc = security.descriptor.from_sddl(sddl, self.domain_sid)
2441             desc_base64 = base64.b64encode(ndr_pack(desc))
2442             mod = """
2443 dn: """ + user_dn + """
2444 changetype: modify
2445 replace: nTSecurityDescriptor
2446 nTSecurityDescriptor:: """ + desc_base64
2447             self.ldb.modify_ldif(mod)
2448             # Read modified descriptor
2449             res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2450             desc = res[0]["nTSecurityDescriptor"][0]
2451             desc = ndr_unpack(security.descriptor, desc)
2452             desc_sddl = desc.as_sddl(self.domain_sid)
2453             self.assertEqual(desc_sddl, sddl)
2454         finally:
2455             self.delete_force(self.ldb, user_dn)
2456         #
2457         # Test modify_ldif() with BASE64 security descriptor input
2458         # New descriptor test
2459         #
2460         try:
2461             self.delete_force(self.ldb, user_dn)
2462             self.ldb.add_ldif("""
2463 dn: """ + user_dn + """
2464 objectclass: user
2465 sAMAccountName: """ + user_name)
2466             # Modify descriptor
2467             sddl = "O:DUG:DUD:PAI(A;;RPWP;;;AU)S:PAI"
2468             desc = security.descriptor.from_sddl(sddl, self.domain_sid)
2469             desc_base64 = base64.b64encode(ndr_pack(desc))
2470             mod = """
2471 dn: """ + user_dn + """
2472 changetype: modify
2473 replace: nTSecurityDescriptor
2474 nTSecurityDescriptor:: """ + desc_base64
2475             self.ldb.modify_ldif(mod)
2476             # Read modified descriptor
2477             res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2478             desc = res[0]["nTSecurityDescriptor"][0]
2479             desc = ndr_unpack(security.descriptor, desc)
2480             desc_sddl = desc.as_sddl(self.domain_sid)
2481             self.assertEqual(desc_sddl, sddl)
2482         finally:
2483             self.delete_force(self.ldb, user_dn)
2484
2485     def test_dsheuristics(self):
2486         """Tests the 'dSHeuristics' attribute"""
2487         print "Tests the 'dSHeuristics' attribute"""
2488
2489         # Get the current value to restore it later
2490         res = self.ldb.search("CN=Directory Service, CN=Windows NT, CN=Services, "
2491                               + self.configuration_dn, scope=SCOPE_BASE, attrs=["dSHeuristics"])
2492         if "dSHeuristics" in res[0]:
2493             dsheuristics = res[0]["dSHeuristics"][0]
2494         else:
2495             dsheuristics = None
2496         # Should not be longer than 18 chars?
2497         try:
2498             self.set_dsheuristics("123ABC-+!1asdfg@#^12")
2499         except LdbError, (num, _):
2500             self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
2501         # If it is >= 10 chars, tenthChar should be 1
2502         try:
2503             self.set_dsheuristics("00020000000002")
2504         except LdbError, (num, _):
2505             self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
2506         # apart from the above, all char values are accepted
2507         self.set_dsheuristics("123ABC-+!1asdfg@#^")
2508         res = self.ldb.search("CN=Directory Service, CN=Windows NT, CN=Services, "
2509                               + self.configuration_dn, scope=SCOPE_BASE, attrs=["dSHeuristics"])
2510         self.assertTrue("dSHeuristics" in res[0])
2511         self.assertEquals(res[0]["dSHeuristics"][0], "123ABC-+!1asdfg@#^")
2512         # restore old value
2513         self.set_dsheuristics(dsheuristics)
2514
2515
2516 class BaseDnTests(unittest.TestCase):
2517
2518     def setUp(self):
2519         super(BaseDnTests, self).setUp()
2520         self.ldb = ldb
2521
2522     def test_rootdse_attrs(self):
2523         """Testing for all rootDSE attributes"""
2524         res = self.ldb.search(scope=SCOPE_BASE, attrs=[])
2525         self.assertEquals(len(res), 1)
2526
2527     def test_highestcommittedusn(self):
2528         """Testing for highestCommittedUSN"""
2529         res = self.ldb.search("", scope=SCOPE_BASE, attrs=["highestCommittedUSN"])
2530         self.assertEquals(len(res), 1)
2531         self.assertTrue(int(res[0]["highestCommittedUSN"][0]) != 0)
2532
2533     def test_netlogon(self):
2534         """Testing for netlogon via LDAP"""
2535         res = self.ldb.search("", scope=SCOPE_BASE, attrs=["netlogon"])
2536         self.assertEquals(len(res), 0)
2537
2538     def test_netlogon_highestcommitted_usn(self):
2539         """Testing for netlogon and highestCommittedUSN via LDAP"""
2540         res = self.ldb.search("", scope=SCOPE_BASE,
2541                 attrs=["netlogon", "highestCommittedUSN"])
2542         self.assertEquals(len(res), 0)
2543
2544     def test_namingContexts(self):
2545         """Testing for namingContexts in rootDSE"""
2546         res = self.ldb.search("", scope=SCOPE_BASE,
2547                 attrs=["namingContexts", "defaultNamingContext", "schemaNamingContext", "configurationNamingContext"])
2548         self.assertEquals(len(res), 1)
2549
2550         ncs = set([])
2551         for nc in res[0]["namingContexts"]:
2552             self.assertTrue(nc not in ncs)
2553             ncs.add(nc)
2554
2555         self.assertTrue(res[0]["defaultNamingContext"][0] in ncs)
2556         self.assertTrue(res[0]["configurationNamingContext"][0] in ncs)
2557         self.assertTrue(res[0]["schemaNamingContext"][0] in ncs)
2558
2559     def test_serverPath(self):
2560         """Testing the server paths in rootDSE"""
2561         res = self.ldb.search("", scope=SCOPE_BASE,
2562                               attrs=["dsServiceName", "serverName"])
2563         self.assertEquals(len(res), 1)
2564
2565         self.assertTrue("CN=Servers" in res[0]["dsServiceName"][0])
2566         self.assertTrue("CN=Sites" in res[0]["dsServiceName"][0])
2567         self.assertTrue("CN=NTDS Settings" in res[0]["dsServiceName"][0])
2568         self.assertTrue("CN=Servers" in res[0]["serverName"][0])
2569         self.assertTrue("CN=Sites" in res[0]["serverName"][0])
2570         self.assertFalse("CN=NTDS Settings" in res[0]["serverName"][0])
2571
2572     def test_dnsHostname(self):
2573         """Testing the DNS hostname in rootDSE"""
2574         res = self.ldb.search("", scope=SCOPE_BASE,
2575                               attrs=["dnsHostName", "serverName"])
2576         self.assertEquals(len(res), 1)
2577
2578         res2 = self.ldb.search(res[0]["serverName"][0], scope=SCOPE_BASE,
2579                                attrs=["dNSHostName"])
2580         self.assertEquals(len(res2), 1)
2581
2582         self.assertEquals(res[0]["dnsHostName"][0], res2[0]["dNSHostName"][0])
2583
2584     def test_ldapServiceName(self):
2585         """Testing the ldap service name in rootDSE"""
2586         res = self.ldb.search("", scope=SCOPE_BASE,
2587                               attrs=["ldapServiceName", "dNSHostName"])
2588         self.assertEquals(len(res), 1)
2589
2590         (hostname, _, dns_domainname) = res[0]["dNSHostName"][0].partition(".")
2591         self.assertTrue(":%s$@%s" % (hostname, dns_domainname.upper())
2592                         in res[0]["ldapServiceName"][0])
2593
2594 if not "://" in host:
2595     if os.path.isfile(host):
2596         host = "tdb://%s" % host
2597     else:
2598         host = "ldap://%s" % host
2599
2600 ldb = Ldb(host, credentials=creds, session_info=system_session(), lp=lp)
2601 if not "tdb://" in host:
2602     gc_ldb = Ldb("%s:3268" % host, credentials=creds,
2603                  session_info=system_session(), lp=lp)
2604 else:
2605     gc_ldb = None
2606
2607 runner = SubunitTestRunner()
2608 rc = 0
2609 if not runner.run(unittest.makeSuite(BaseDnTests)).wasSuccessful():
2610     rc = 1
2611 if not runner.run(unittest.makeSuite(BasicTests)).wasSuccessful():
2612     rc = 1
2613 sys.exit(rc)