source4/dsdb/tests/python/ldap.py

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