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