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