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