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 # Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2008-2011
   6 #
   7 # This program is free software; you can redistribute it and/or modify
   8 # it under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation; either version 3 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # This program is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 # GNU General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License
  18 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 from __future__ import print_function
  21 import optparse
  22 import sys
  23 import time
  24 import base64
  25 import os
  26
  27 sys.path.insert(0, "bin/python")
  28 import samba
  29 from samba.tests.subunitrun import SubunitOptions, TestProgram
  30 import samba.getopt as options
  31
  32 from samba.auth import system_session
  33 from ldb import SCOPE_SUBTREE, SCOPE_ONELEVEL, SCOPE_BASE, LdbError
  34 from ldb import ERR_NO_SUCH_OBJECT, ERR_ATTRIBUTE_OR_VALUE_EXISTS
  35 from ldb import ERR_ENTRY_ALREADY_EXISTS, ERR_UNWILLING_TO_PERFORM
  36 from ldb import ERR_NOT_ALLOWED_ON_NON_LEAF, ERR_OTHER, ERR_INVALID_DN_SYNTAX
  37 from ldb import ERR_NO_SUCH_ATTRIBUTE, ERR_INVALID_ATTRIBUTE_SYNTAX
  38 from ldb import ERR_OBJECT_CLASS_VIOLATION, ERR_NOT_ALLOWED_ON_RDN
  39 from ldb import ERR_NAMING_VIOLATION, ERR_CONSTRAINT_VIOLATION
  40 from ldb import Message, MessageElement, Dn
  41 from ldb import FLAG_MOD_ADD, FLAG_MOD_REPLACE, FLAG_MOD_DELETE
  42 from ldb import timestring
  43 from samba import Ldb
  44 from samba.samdb import SamDB
  45 from samba.dsdb import (UF_NORMAL_ACCOUNT,
  46     UF_WORKSTATION_TRUST_ACCOUNT,
  47     UF_PASSWD_NOTREQD, UF_ACCOUNTDISABLE, ATYPE_NORMAL_ACCOUNT,
  48     ATYPE_WORKSTATION_TRUST, SYSTEM_FLAG_DOMAIN_DISALLOW_MOVE,
  49     SYSTEM_FLAG_CONFIG_ALLOW_RENAME, SYSTEM_FLAG_CONFIG_ALLOW_MOVE,
  50     SYSTEM_FLAG_CONFIG_ALLOW_LIMITED_MOVE)
  51
  52 from samba.ndr import ndr_pack, ndr_unpack
  53 from samba.dcerpc import security, lsa
  54 from samba.tests import delete_force
  55
  56 parser = optparse.OptionParser("ldap.py [options] <host>")
  57 sambaopts = options.SambaOptions(parser)
  58 parser.add_option_group(sambaopts)
  59 parser.add_option_group(options.VersionOptions(parser))
  60 # use command line creds if available
  61 credopts = options.CredentialsOptions(parser)
  62 parser.add_option_group(credopts)
  63 subunitopts = SubunitOptions(parser)
  64 parser.add_option_group(subunitopts)
  65 opts, args = parser.parse_args()
  66
  67 if len(args) < 1:
  68     parser.print_usage()
  69     sys.exit(1)
  70
  71 host = args[0]
  72
  73 lp = sambaopts.get_loadparm()
  74 creds = credopts.get_credentials(lp)
  75
  76 class BasicTests(samba.tests.TestCase):
  77
  78     def setUp(self):
  79         super(BasicTests, self).setUp()
  80         self.ldb = ldb
  81         self.gc_ldb = gc_ldb
  82         self.base_dn = ldb.domain_dn()
  83         self.configuration_dn = ldb.get_config_basedn().get_linearized()
  84         self.schema_dn = ldb.get_schema_basedn().get_linearized()
  85         self.domain_sid = security.dom_sid(ldb.get_domain_sid())
  86
  87         delete_force(self.ldb, "cn=posixuser,cn=users," + self.base_dn)
  88         delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
  89         delete_force(self.ldb, "cn=ldaptestuser2,cn=users," + self.base_dn)
  90         delete_force(self.ldb, "cn=ldaptestuser3,cn=users," + self.base_dn)
  91         delete_force(self.ldb, "cn=ldaptestuser4,cn=ldaptestcontainer," + self.base_dn)
  92         delete_force(self.ldb, "cn=ldaptestuser4,cn=ldaptestcontainer2," + self.base_dn)
  93         delete_force(self.ldb, "cn=ldaptestuser5,cn=users," + self.base_dn)
  94         delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
  95         delete_force(self.ldb, "cn=ldaptestgroup2,cn=users," + self.base_dn)
  96         delete_force(self.ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
  97         delete_force(self.ldb, "cn=ldaptest2computer,cn=computers," + self.base_dn)
  98         delete_force(self.ldb, "cn=ldaptestcomputer3,cn=computers," + self.base_dn)
  99         delete_force(self.ldb, "cn=ldaptestutf8user èùéìòà,cn=users," + self.base_dn)
 100         delete_force(self.ldb, "cn=ldaptestutf8user2  èùéìòà,cn=users," + self.base_dn)
 101         delete_force(self.ldb, "cn=ldaptestcontainer," + self.base_dn)
 102         delete_force(self.ldb, "cn=ldaptestcontainer2," + self.base_dn)
 103         delete_force(self.ldb, "cn=parentguidtest,cn=users," + self.base_dn)
 104         delete_force(self.ldb, "cn=parentguidtest,cn=testotherusers," + self.base_dn)
 105         delete_force(self.ldb, "cn=testotherusers," + self.base_dn)
 106         delete_force(self.ldb, "cn=ldaptestobject," + self.base_dn)
 107         delete_force(self.ldb, "description=xyz,cn=users," + self.base_dn)
 108         delete_force(self.ldb, "ou=testou,cn=users," + self.base_dn)
 109         delete_force(self.ldb, "cn=Test Secret,cn=system," + self.base_dn)
 110         delete_force(self.ldb, "cn=testtimevaluesuser1,cn=users," + self.base_dn)
 111
 112     def test_objectclasses(self):
 113         """Test objectClass behaviour"""
 114         # Invalid objectclass specified
 115         try:
 116             self.ldb.add({
 117                 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
 118                 "objectClass": [] })
 119             self.fail()
 120         except LdbError as e1:
 121             (num, _) = e1.args
 122             self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
 123
 124         # Invalid objectclass specified
 125         try:
 126             self.ldb.add({
 127                 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
 128                 "objectClass": "X" })
 129             self.fail()
 130         except LdbError as e2:
 131             (num, _) = e2.args
 132             self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
 133
 134         # Invalid objectCategory specified
 135         try:
 136             self.ldb.add({
 137                 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
 138                 "objectClass": "person",
 139                 "objectCategory": self.base_dn })
 140             self.fail()
 141         except LdbError as e3:
 142             (num, _) = e3.args
 143             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 144
 145         # Multi-valued "systemFlags"
 146         try:
 147             self.ldb.add({
 148                 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
 149                 "objectClass": "person",
 150                 "systemFlags": ["0", str(SYSTEM_FLAG_DOMAIN_DISALLOW_MOVE)] })
 151             self.fail()
 152         except LdbError as e4:
 153             (num, _) = e4.args
 154             self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
 155
 156         # We cannot instanciate from an abstract object class ("connectionPoint"
 157         # or "leaf"). In the first case we use "connectionPoint" (subclass of
 158         # "leaf") to prevent a naming violation - this returns us a
 159         # "ERR_UNWILLING_TO_PERFORM" since it is not structural. In the second
 160         # case however we get "ERR_OBJECT_CLASS_VIOLATION" since an abstract
 161         # class is also not allowed to be auxiliary.
 162         try:
 163             self.ldb.add({
 164                 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
 165                 "objectClass": "connectionPoint" })
 166             self.fail()
 167         except LdbError as e5:
 168             (num, _) = e5.args
 169             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
 170         try:
 171             self.ldb.add({
 172                 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
 173                 "objectClass": ["person", "leaf"] })
 174             self.fail()
 175         except LdbError as e6:
 176             (num, _) = e6.args
 177             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 178
 179         # Objects instanciated using "satisfied" abstract classes (concrete
 180         # subclasses) are allowed
 181         self.ldb.add({
 182              "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
 183              "objectClass": ["top", "leaf", "connectionPoint", "serviceConnectionPoint"] })
 184
 185         delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 186
 187         # Two disjoint top-most structural object classes aren't allowed
 188         try:
 189             self.ldb.add({
 190                 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
 191                 "objectClass": ["person", "container"] })
 192             self.fail()
 193         except LdbError as e7:
 194             (num, _) = e7.args
 195             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 196
 197         # Test allowed system flags
 198         self.ldb.add({
 199              "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
 200              "objectClass": "person",
 201              "systemFlags": str(~(SYSTEM_FLAG_CONFIG_ALLOW_RENAME | SYSTEM_FLAG_CONFIG_ALLOW_MOVE | SYSTEM_FLAG_CONFIG_ALLOW_LIMITED_MOVE)) })
 202
 203         res = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
 204                          scope=SCOPE_BASE, attrs=["systemFlags"])
 205         self.assertTrue(len(res) == 1)
 206         self.assertEquals(res[0]["systemFlags"][0], "0")
 207
 208         delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 209
 210         self.ldb.add({
 211              "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
 212              "objectClass": "person" })
 213
 214         # We can remove derivation classes of the structural objectclass
 215         # but they're going to be readded afterwards
 216         m = Message()
 217         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 218         m["objectClass"] = MessageElement("top", FLAG_MOD_DELETE,
 219           "objectClass")
 220         ldb.modify(m)
 221
 222         res = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
 223                          scope=SCOPE_BASE, attrs=["objectClass"])
 224         self.assertTrue(len(res) == 1)
 225         self.assertTrue("top" in res[0]["objectClass"])
 226
 227         # The top-most structural class cannot be deleted since there are
 228         # attributes of it in use
 229         m = Message()
 230         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 231         m["objectClass"] = MessageElement("person", FLAG_MOD_DELETE,
 232           "objectClass")
 233         try:
 234             ldb.modify(m)
 235             self.fail()
 236         except LdbError as e8:
 237             (num, _) = e8.args
 238             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 239
 240         # We cannot delete classes which weren't specified
 241         m = Message()
 242         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 243         m["objectClass"] = MessageElement("computer", FLAG_MOD_DELETE,
 244           "objectClass")
 245         try:
 246             ldb.modify(m)
 247             self.fail()
 248         except LdbError as e9:
 249             (num, _) = e9.args
 250             self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
 251
 252         # An invalid class cannot be added
 253         m = Message()
 254         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 255         m["objectClass"] = MessageElement("X", FLAG_MOD_ADD,
 256           "objectClass")
 257         try:
 258             ldb.modify(m)
 259             self.fail()
 260         except LdbError as e10:
 261             (num, _) = e10.args
 262             self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
 263
 264         # We cannot add a the new top-most structural class "user" here since
 265         # we are missing at least one new mandatory attribute (in this case
 266         # "sAMAccountName")
 267         m = Message()
 268         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 269         m["objectClass"] = MessageElement("user", FLAG_MOD_ADD,
 270           "objectClass")
 271         try:
 272             ldb.modify(m)
 273             self.fail()
 274         except LdbError as e11:
 275             (num, _) = e11.args
 276             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 277
 278         # An already specified objectclass cannot be added another time
 279         m = Message()
 280         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 281         m["objectClass"] = MessageElement("person", FLAG_MOD_ADD,
 282           "objectClass")
 283         try:
 284             ldb.modify(m)
 285             self.fail()
 286         except LdbError as e12:
 287             (num, _) = e12.args
 288             self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
 289
 290         # Auxiliary classes can always be added
 291         m = Message()
 292         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 293         m["objectClass"] = MessageElement("bootableDevice", FLAG_MOD_ADD,
 294           "objectClass")
 295         ldb.modify(m)
 296
 297         # This does not work since object class "leaf" is not auxiliary nor it
 298         # stands in direct relation to "person" (and it is abstract too!)
 299         m = Message()
 300         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 301         m["objectClass"] = MessageElement("leaf", FLAG_MOD_ADD,
 302           "objectClass")
 303         try:
 304             ldb.modify(m)
 305             self.fail()
 306         except LdbError as e13:
 307             (num, _) = e13.args
 308             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 309
 310         # Objectclass replace operations can be performed as well
 311         m = Message()
 312         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 313         m["objectClass"] = MessageElement(["top", "person", "bootableDevice"],
 314           FLAG_MOD_REPLACE, "objectClass")
 315         ldb.modify(m)
 316
 317         m = Message()
 318         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 319         m["objectClass"] = MessageElement(["person", "bootableDevice"],
 320           FLAG_MOD_REPLACE, "objectClass")
 321         ldb.modify(m)
 322
 323         # This does not work since object class "leaf" is not auxiliary nor it
 324         # stands in direct relation to "person" (and it is abstract too!)
 325         m = Message()
 326         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 327         m["objectClass"] = MessageElement(["top", "person", "bootableDevice",
 328           "leaf"], FLAG_MOD_REPLACE, "objectClass")
 329         try:
 330             ldb.modify(m)
 331             self.fail()
 332         except LdbError as e14:
 333             (num, _) = e14.args
 334             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 335
 336         # More than one change operation is allowed
 337         m = Message()
 338         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 339         m.add(MessageElement("bootableDevice", FLAG_MOD_DELETE, "objectClass"))
 340         m.add(MessageElement("bootableDevice", FLAG_MOD_ADD, "objectClass"))
 341         ldb.modify(m)
 342
 343         # We cannot remove all object classes by an empty replace
 344         m = Message()
 345         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 346         m["objectClass"] = MessageElement([], FLAG_MOD_REPLACE, "objectClass")
 347         try:
 348             ldb.modify(m)
 349             self.fail()
 350         except LdbError as e15:
 351             (num, _) = e15.args
 352             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 353
 354         m = Message()
 355         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 356         m["objectClass"] = MessageElement(["top", "computer"], FLAG_MOD_REPLACE,
 357           "objectClass")
 358         try:
 359             ldb.modify(m)
 360             self.fail()
 361         except LdbError as e16:
 362             (num, _) = e16.args
 363             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 364
 365         # Classes can be removed unless attributes of them are used.
 366         m = Message()
 367         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 368         m["objectClass"] = MessageElement("bootableDevice", FLAG_MOD_DELETE,
 369           "objectClass")
 370         ldb.modify(m)
 371
 372         res = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
 373                          scope=SCOPE_BASE, attrs=["objectClass"])
 374         self.assertTrue(len(res) == 1)
 375         self.assertFalse("bootableDevice" in res[0]["objectClass"])
 376
 377         m = Message()
 378         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 379         m["objectClass"] = MessageElement("bootableDevice", FLAG_MOD_ADD,
 380           "objectClass")
 381         ldb.modify(m)
 382
 383         # Add an attribute specific to the "bootableDevice" class
 384         m = Message()
 385         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 386         m["bootParameter"] = MessageElement("test", FLAG_MOD_ADD,
 387           "bootParameter")
 388         ldb.modify(m)
 389
 390         # Classes can be removed unless attributes of them are used. Now there
 391         # exist such attributes on the entry.
 392         m = Message()
 393         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 394         m["objectClass"] = MessageElement("bootableDevice", FLAG_MOD_DELETE,
 395           "objectClass")
 396         try:
 397             ldb.modify(m)
 398             self.fail()
 399         except LdbError as e17:
 400             (num, _) = e17.args
 401             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 402
 403         # Remove the previously specified attribute
 404         m = Message()
 405         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 406         m["bootParameter"] = MessageElement("test", FLAG_MOD_DELETE,
 407           "bootParameter")
 408         ldb.modify(m)
 409
 410         # Classes can be removed unless attributes of them are used.
 411         m = Message()
 412         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 413         m["objectClass"] = MessageElement("bootableDevice", FLAG_MOD_DELETE,
 414           "objectClass")
 415         ldb.modify(m)
 416
 417         delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 418
 419         self.ldb.add({
 420              "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
 421              "objectClass": "user" })
 422
 423         # Add a new top-most structural class "container". This does not work
 424         # since it stands in no direct relation to the current one.
 425         m = Message()
 426         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 427         m["objectClass"] = MessageElement("container", FLAG_MOD_ADD,
 428           "objectClass")
 429         try:
 430             ldb.modify(m)
 431             self.fail()
 432         except LdbError as e18:
 433             (num, _) = e18.args
 434             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 435
 436         # Add a new top-most structural class "inetOrgPerson" and remove it
 437         # afterwards
 438         m = Message()
 439         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 440         m["objectClass"] = MessageElement("inetOrgPerson", FLAG_MOD_ADD,
 441           "objectClass")
 442         ldb.modify(m)
 443
 444         m = Message()
 445         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 446         m["objectClass"] = MessageElement("inetOrgPerson", FLAG_MOD_DELETE,
 447           "objectClass")
 448         ldb.modify(m)
 449
 450         # Replace top-most structural class to "inetOrgPerson" and reset it
 451         # back to "user"
 452         m = Message()
 453         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 454         m["objectClass"] = MessageElement("inetOrgPerson", FLAG_MOD_REPLACE,
 455           "objectClass")
 456         ldb.modify(m)
 457
 458         m = Message()
 459         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 460         m["objectClass"] = MessageElement("user", FLAG_MOD_REPLACE,
 461           "objectClass")
 462         ldb.modify(m)
 463
 464         # Add a new auxiliary object class "posixAccount" to "ldaptestuser"
 465         m = Message()
 466         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 467         m["objectClass"] = MessageElement("posixAccount", FLAG_MOD_ADD,
 468           "objectClass")
 469         ldb.modify(m)
 470
 471         # Be sure that "top" is the first and the (most) structural object class
 472         # the last value of the "objectClass" attribute - MS-ADTS 3.1.1.1.4
 473         res = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
 474                          scope=SCOPE_BASE, attrs=["objectClass"])
 475         self.assertTrue(len(res) == 1)
 476         self.assertEquals(res[0]["objectClass"][0], "top")
 477         self.assertEquals(res[0]["objectClass"][len(res[0]["objectClass"])-1], "user")
 478
 479         delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 480
 481     def test_system_only(self):
 482         """Test systemOnly objects"""
 483         try:
 484             self.ldb.add({
 485                 "dn": "cn=ldaptestobject," + self.base_dn,
 486                 "objectclass": "configuration"})
 487             self.fail()
 488         except LdbError as e19:
 489             (num, _) = e19.args
 490             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
 491
 492         try:
 493             self.ldb.add({
 494                 "dn": "cn=Test Secret,cn=system," + self.base_dn,
 495                 "objectclass": "secret"})
 496             self.fail()
 497         except LdbError as e20:
 498             (num, _) = e20.args
 499             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
 500
 501         delete_force(self.ldb, "cn=ldaptestobject," + self.base_dn)
 502         delete_force(self.ldb, "cn=Test Secret,cn=system," + self.base_dn)
 503
 504         # Create secret over LSA and try to change it
 505
 506         lsa_conn = lsa.lsarpc("ncacn_np:%s" % args[0], lp, creds)
 507         lsa_handle = lsa_conn.OpenPolicy2(system_name="\\",
 508                                           attr=lsa.ObjectAttribute(),
 509                                           access_mask=security.SEC_FLAG_MAXIMUM_ALLOWED)
 510         secret_name = lsa.String()
 511         secret_name.string = "G$Test"
 512         sec_handle = lsa_conn.CreateSecret(handle=lsa_handle,
 513                                            name=secret_name,
 514                                            access_mask=security.SEC_FLAG_MAXIMUM_ALLOWED)
 515         lsa_conn.Close(lsa_handle)
 516
 517         m = Message()
 518         m.dn = Dn(ldb, "cn=Test Secret,cn=system," + self.base_dn)
 519         m["description"] = MessageElement("desc", FLAG_MOD_REPLACE,
 520           "description")
 521         try:
 522             ldb.modify(m)
 523             self.fail()
 524         except LdbError as e21:
 525             (num, _) = e21.args
 526             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
 527
 528         delete_force(self.ldb, "cn=Test Secret,cn=system," + self.base_dn)
 529
 530         try:
 531             self.ldb.add({
 532                 "dn": "cn=ldaptestcontainer," + self.base_dn,
 533                 "objectclass": "container",
 534                 "isCriticalSystemObject": "TRUE"})
 535             self.fail()
 536         except LdbError as e22:
 537             (num, _) = e22.args
 538             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
 539
 540         self.ldb.add({
 541             "dn": "cn=ldaptestcontainer," + self.base_dn,
 542             "objectclass": "container"})
 543
 544         m = Message()
 545         m.dn = Dn(ldb, "cn=ldaptestcontainer," + self.base_dn)
 546         m["isCriticalSystemObject"] = MessageElement("TRUE", FLAG_MOD_REPLACE,
 547           "isCriticalSystemObject")
 548         try:
 549             ldb.modify(m)
 550             self.fail()
 551         except LdbError as e23:
 552             (num, _) = e23.args
 553             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
 554
 555         delete_force(self.ldb, "cn=ldaptestcontainer," + self.base_dn)
 556
 557         # Proof if DC SAM object has "isCriticalSystemObject" set
 558         res = self.ldb.search("", scope=SCOPE_BASE, attrs=["serverName"])
 559         self.assertTrue(len(res) == 1)
 560         self.assertTrue("serverName" in res[0])
 561         res = self.ldb.search(res[0]["serverName"][0], scope=SCOPE_BASE,
 562                               attrs=["serverReference"])
 563         self.assertTrue(len(res) == 1)
 564         self.assertTrue("serverReference" in res[0])
 565         res = self.ldb.search(res[0]["serverReference"][0], scope=SCOPE_BASE,
 566                               attrs=["isCriticalSystemObject"])
 567         self.assertTrue(len(res) == 1)
 568         self.assertTrue("isCriticalSystemObject" in res[0])
 569         self.assertEquals(res[0]["isCriticalSystemObject"][0], "TRUE")
 570
 571     def test_invalid_parent(self):
 572         """Test adding an object with invalid parent"""
 573         try:
 574             self.ldb.add({
 575                 "dn": "cn=ldaptestgroup,cn=thisdoesnotexist123,"
 576                    + self.base_dn,
 577                 "objectclass": "group"})
 578             self.fail()
 579         except LdbError as e24:
 580             (num, _) = e24.args
 581             self.assertEquals(num, ERR_NO_SUCH_OBJECT)
 582
 583         delete_force(self.ldb, "cn=ldaptestgroup,cn=thisdoesnotexist123,"
 584           + self.base_dn)
 585
 586         try:
 587             self.ldb.add({
 588                 "dn": "ou=testou,cn=users," + self.base_dn,
 589                 "objectclass": "organizationalUnit"})
 590             self.fail()
 591         except LdbError as e25:
 592             (num, _) = e25.args
 593             self.assertEquals(num, ERR_NAMING_VIOLATION)
 594
 595         delete_force(self.ldb, "ou=testou,cn=users," + self.base_dn)
 596
 597     def test_invalid_attribute(self):
 598         """Test invalid attributes on schema/objectclasses"""
 599         # attributes not in schema test
 600
 601         # add operation
 602
 603         try:
 604             self.ldb.add({
 605                 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
 606                 "objectclass": "group",
 607                 "thisdoesnotexist": "x"})
 608             self.fail()
 609         except LdbError as e26:
 610             (num, _) = e26.args
 611             self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
 612
 613         self.ldb.add({
 614              "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
 615              "objectclass": "group"})
 616
 617         # modify operation
 618
 619         m = Message()
 620         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 621         m["thisdoesnotexist"] = MessageElement("x", FLAG_MOD_REPLACE,
 622           "thisdoesnotexist")
 623         try:
 624             ldb.modify(m)
 625             self.fail()
 626         except LdbError as e27:
 627             (num, _) = e27.args
 628             self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
 629
 630         delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 631
 632         # attributes not in objectclasses and mandatory attributes missing test
 633         # Use here a non-SAM entry since it doesn't have special triggers
 634         # associated which have an impact on the error results.
 635
 636         # add operations
 637
 638         # mandatory attribute missing
 639         try:
 640             self.ldb.add({
 641                 "dn": "cn=ldaptestobject," + self.base_dn,
 642                 "objectclass": "ipProtocol"})
 643             self.fail()
 644         except LdbError as e28:
 645             (num, _) = e28.args
 646             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 647
 648         # inadequate but schema-valid attribute specified
 649         try:
 650             self.ldb.add({
 651                 "dn": "cn=ldaptestobject," + self.base_dn,
 652                 "objectclass": "ipProtocol",
 653                 "ipProtocolNumber": "1",
 654                 "uid" : "0"})
 655             self.fail()
 656         except LdbError as e29:
 657             (num, _) = e29.args
 658             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 659
 660         self.ldb.add({
 661             "dn": "cn=ldaptestobject," + self.base_dn,
 662             "objectclass": "ipProtocol",
 663             "ipProtocolNumber": "1"})
 664
 665         # modify operations
 666
 667         # inadequate but schema-valid attribute add trial
 668         m = Message()
 669         m.dn = Dn(ldb, "cn=ldaptestobject," + self.base_dn)
 670         m["uid"] = MessageElement("0", FLAG_MOD_ADD, "uid")
 671         try:
 672             ldb.modify(m)
 673             self.fail()
 674         except LdbError as e30:
 675             (num, _) = e30.args
 676             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 677
 678         # mandatory attribute delete trial
 679         m = Message()
 680         m.dn = Dn(ldb, "cn=ldaptestobject," + self.base_dn)
 681         m["ipProtocolNumber"] = MessageElement([], FLAG_MOD_DELETE,
 682           "ipProtocolNumber")
 683         try:
 684             ldb.modify(m)
 685             self.fail()
 686         except LdbError as e31:
 687             (num, _) = e31.args
 688             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 689
 690         # mandatory attribute delete trial
 691         m = Message()
 692         m.dn = Dn(ldb, "cn=ldaptestobject," + self.base_dn)
 693         m["ipProtocolNumber"] = MessageElement([], FLAG_MOD_REPLACE,
 694           "ipProtocolNumber")
 695         try:
 696             ldb.modify(m)
 697             self.fail()
 698         except LdbError as e32:
 699             (num, _) = e32.args
 700             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 701
 702         delete_force(self.ldb, "cn=ldaptestobject," + self.base_dn)
 703
 704     def test_single_valued_attributes(self):
 705         """Test single-valued attributes"""
 706         try:
 707             self.ldb.add({
 708                 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
 709                 "objectclass": "group",
 710                 "sAMAccountName": ["nam1", "nam2"]})
 711             self.fail()
 712         except LdbError as e33:
 713             (num, _) = e33.args
 714             self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
 715
 716         self.ldb.add({
 717              "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
 718              "objectclass": "group"})
 719
 720         m = Message()
 721         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 722         m["sAMAccountName"] = MessageElement(["nam1","nam2"], FLAG_MOD_REPLACE,
 723           "sAMAccountName")
 724         try:
 725             ldb.modify(m)
 726             self.fail()
 727         except LdbError as e34:
 728             (num, _) = e34.args
 729             self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
 730
 731         m = Message()
 732         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 733         m["sAMAccountName"] = MessageElement("testgroupXX", FLAG_MOD_REPLACE,
 734           "sAMAccountName")
 735         ldb.modify(m)
 736
 737         m = Message()
 738         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 739         m["sAMAccountName"] = MessageElement("testgroupXX2", FLAG_MOD_ADD,
 740           "sAMAccountName")
 741         try:
 742             ldb.modify(m)
 743             self.fail()
 744         except LdbError as e35:
 745             (num, _) = e35.args
 746             self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
 747
 748         delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 749
 750     def test_single_valued_linked_attributes(self):
 751         """Test managedBy, a single-valued linked attribute.
 752
 753         (The single-valuedness of this is enforced differently, in
 754         repl_meta_data.c)
 755         """
 756         ou = 'OU=svla,%s' % (self.base_dn)
 757
 758         delete_force(self.ldb, ou, controls=['tree_delete:1'])
 759
 760         self.ldb.add({'objectclass': 'organizationalUnit',
 761                       'dn': ou})
 762
 763
 764         managers = []
 765         for x in range(3):
 766             m = "cn=manager%d,%s" % (x, ou)
 767             self.ldb.add({
 768                 "dn": m,
 769                 "objectclass": "user"})
 770             managers.append(m)
 771
 772         try:
 773             self.ldb.add({
 774                 "dn": "cn=group1," + ou,
 775                 "objectclass": "group",
 776                 "managedBy": managers
 777             })
 778             self.fail("failed to fail to add multiple managedBy attributes")
 779         except LdbError as e36:
 780             (num, _) = e36.args
 781             self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
 782
 783         managee = "cn=group2," + ou
 784         self.ldb.add({
 785             "dn": managee,
 786             "objectclass": "group",
 787             "managedBy": [managers[0]]})
 788
 789         m = Message()
 790         m.dn = Dn(ldb, managee)
 791         m["managedBy"] = MessageElement(managers, FLAG_MOD_REPLACE,
 792                                         "managedBy")
 793         try:
 794             ldb.modify(m)
 795             self.fail()
 796         except LdbError as e37:
 797             (num, _) = e37.args
 798             self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
 799
 800         m = Message()
 801         m.dn = Dn(ldb, managee)
 802         m["managedBy"] = MessageElement(managers[1], FLAG_MOD_REPLACE,
 803                                         "managedBy")
 804         ldb.modify(m)
 805
 806         m = Message()
 807         m.dn = Dn(ldb, managee)
 808         m["managedBy"] = MessageElement(managers[2], FLAG_MOD_ADD,
 809                                         "managedBy")
 810         try:
 811             ldb.modify(m)
 812             self.fail()
 813         except LdbError as e38:
 814             (num, _) = e38.args
 815             self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
 816
 817         self.ldb.delete(ou, ['tree_delete:1'])
 818
 819
 820     def test_multivalued_attributes(self):
 821         """Test multi-valued attributes"""
 822         ou = 'OU=mvattr,%s' % (self.base_dn)
 823         delete_force(self.ldb, ou, controls=['tree_delete:1'])
 824         self.ldb.add({'objectclass': 'organizationalUnit',
 825                       'dn': ou})
 826
 827         # beyond 1210, Win2012r2 gives LDAP_ADMIN_LIMIT_EXCEEDED
 828         ranges = (3, 30, 300, 1210)
 829
 830         for n in ranges:
 831             self.ldb.add({
 832                 "dn": "cn=ldaptestuser%d,%s" % (n, ou),
 833                 "objectclass": "user",
 834                 "carLicense": ["car%d" % x for x in range(n)]})
 835
 836         # add some more
 837         for n in ranges:
 838             m = Message()
 839             m.dn = Dn(ldb, "cn=ldaptestuser%d,%s" % (n, ou))
 840             m["carLicense"] = MessageElement(["another"],
 841                                              FLAG_MOD_ADD,
 842                                              "carLicense")
 843             ldb.modify(m)
 844
 845             m = Message()
 846             m.dn = Dn(ldb, "cn=ldaptestuser%d,%s" % (n, ou))
 847             m["carLicense"] = MessageElement(["foo%d" % x for x in range(4)],
 848                                              FLAG_MOD_ADD,
 849                                              "carLicense")
 850             ldb.modify(m)
 851
 852             m = Message()
 853             m.dn = Dn(ldb, "cn=ldaptestuser%d,%s" % (n, ou))
 854             m["carLicense"] = MessageElement(["bar%d" % x for x in range(40)],
 855                                              FLAG_MOD_ADD,
 856                                              "carLicense")
 857             ldb.modify(m)
 858
 859         for n in ranges:
 860             m = Message()
 861             dn = "cn=ldaptestuser%d,%s" % (n, ou)
 862             m.dn = Dn(ldb, dn)
 863             m["carLicense"] = MessageElement(["replacement"],
 864                                              FLAG_MOD_REPLACE,
 865                                              "carLicense")
 866             ldb.modify(m)
 867
 868             m = Message()
 869             m.dn = Dn(ldb, dn)
 870             m["carLicense"] = MessageElement(["replacement%d" % x for x in range(n)],
 871                                              FLAG_MOD_REPLACE,
 872                                              "carLicense")
 873             ldb.modify(m)
 874
 875             m = Message()
 876             m.dn = Dn(ldb, dn)
 877             m["carLicense"] = MessageElement(["again%d" % x for x in range(n)],
 878                                              FLAG_MOD_REPLACE,
 879                                              "carLicense")
 880             ldb.modify(m)
 881
 882             m = Message()
 883             m.dn = Dn(ldb, dn)
 884             m["carLicense"] = MessageElement(["andagain%d" % x for x in range(n)],
 885                                              FLAG_MOD_REPLACE,
 886                                              "carLicense")
 887             ldb.modify(m)
 888
 889         self.ldb.delete(ou, ['tree_delete:1'])
 890
 891
 892     def test_attribute_ranges(self):
 893         """Test attribute ranges"""
 894         # Too short (min. 1)
 895         try:
 896             ldb.add({
 897                "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
 898                "objectClass": "person",
 899                "sn": "" })
 900             self.fail()
 901         except LdbError as e39:
 902             (num, _) = e39.args
 903             self.assertEquals(num, ERR_INVALID_ATTRIBUTE_SYNTAX)
 904
 905         # Too long (max. 64)
 906 #        try:
 907 #            ldb.add({
 908 #               "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
 909 #               "objectClass": "person",
 910 #               "sn": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" })
 911 #            self.fail()
 912 #        except LdbError, (num, _):
 913 #            self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
 914
 915         ldb.add({
 916            "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
 917            "objectClass": "person" })
 918
 919         # Too short (min. 1)
 920         m = Message()
 921         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 922         m["sn"] = MessageElement("", FLAG_MOD_REPLACE, "sn")
 923         try:
 924             ldb.modify(m)
 925             self.fail()
 926         except LdbError as e40:
 927             (num, _) = e40.args
 928             self.assertEquals(num, ERR_INVALID_ATTRIBUTE_SYNTAX)
 929
 930         # Too long (max. 64)
 931 #        m = Message()
 932 #        m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 933 #        m["sn"] = MessageElement("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", FLAG_MOD_REPLACE, "sn")
 934 #        try:
 935 #            ldb.modify(m)
 936 #            self.fail()
 937 #        except LdbError, (num, _):
 938 #            self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
 939
 940         m = Message()
 941         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 942         m["sn"] = MessageElement("x", FLAG_MOD_REPLACE, "sn")
 943         ldb.modify(m)
 944
 945         delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
 946
 947     def test_empty_messages(self):
 948         """Test empty messages"""
 949         m = Message()
 950         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 951
 952         try:
 953             ldb.add(m)
 954             self.fail()
 955         except LdbError as e41:
 956             (num, _) = e41.args
 957             self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
 958
 959         try:
 960             ldb.modify(m)
 961             self.fail()
 962         except LdbError as e42:
 963             (num, _) = e42.args
 964             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
 965
 966         delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 967
 968     def test_empty_attributes(self):
 969         """Test empty attributes"""
 970         m = Message()
 971         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 972         m["objectClass"] = MessageElement("group", FLAG_MOD_ADD, "objectClass")
 973         m["description"] = MessageElement([], FLAG_MOD_ADD, "description")
 974
 975         try:
 976             ldb.add(m)
 977             self.fail()
 978         except LdbError as e43:
 979             (num, _) = e43.args
 980             self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
 981
 982         self.ldb.add({
 983             "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
 984             "objectclass": "group"})
 985
 986         m = Message()
 987         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 988         m["description"] = MessageElement([], FLAG_MOD_ADD, "description")
 989
 990         try:
 991             ldb.modify(m)
 992             self.fail()
 993         except LdbError as e44:
 994             (num, _) = e44.args
 995             self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
 996
 997         m = Message()
 998         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
 999         m["description"] = MessageElement([], FLAG_MOD_REPLACE, "description")
1000         ldb.modify(m)
1001
1002         m = Message()
1003         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1004         m["description"] = MessageElement([], FLAG_MOD_DELETE, "description")
1005         try:
1006             ldb.modify(m)
1007             self.fail()
1008         except LdbError as e45:
1009             (num, _) = e45.args
1010             self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
1011
1012         delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1013
1014     def test_instanceType(self):
1015         """Tests the 'instanceType' attribute"""
1016         # The instance type is single-valued
1017         try:
1018             self.ldb.add({
1019                 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
1020                 "objectclass": "group",
1021                 "instanceType": ["0", "1"]})
1022             self.fail()
1023         except LdbError as e46:
1024             (num, _) = e46.args
1025             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1026
1027         # The head NC flag cannot be set without the write flag
1028         try:
1029             self.ldb.add({
1030                 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
1031                 "objectclass": "group",
1032                 "instanceType": "1" })
1033             self.fail()
1034         except LdbError as e47:
1035             (num, _) = e47.args
1036             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1037
1038         # We cannot manipulate NCs without the head NC flag
1039         try:
1040             self.ldb.add({
1041                 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
1042                 "objectclass": "group",
1043                 "instanceType": "32" })
1044             self.fail()
1045         except LdbError as e48:
1046             (num, _) = e48.args
1047             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1048
1049         self.ldb.add({
1050              "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
1051              "objectclass": "group"})
1052
1053         m = Message()
1054         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1055         m["instanceType"] = MessageElement("0", FLAG_MOD_REPLACE,
1056           "instanceType")
1057         try:
1058             ldb.modify(m)
1059             self.fail()
1060         except LdbError as e49:
1061             (num, _) = e49.args
1062             self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
1063
1064         m = Message()
1065         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1066         m["instanceType"] = MessageElement([], FLAG_MOD_REPLACE,
1067           "instanceType")
1068         try:
1069             ldb.modify(m)
1070             self.fail()
1071         except LdbError as e50:
1072             (num, _) = e50.args
1073             self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
1074
1075         m = Message()
1076         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1077         m["instanceType"] = MessageElement([], FLAG_MOD_DELETE, "instanceType")
1078         try:
1079             ldb.modify(m)
1080             self.fail()
1081         except LdbError as e51:
1082             (num, _) = e51.args
1083             self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
1084
1085         delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1086
1087         #only write is allowed with NC_HEAD for originating updates
1088         try:
1089             self.ldb.add({
1090                 "dn": "cn=ldaptestuser2,cn=users," + self.base_dn,
1091                 "objectclass": "user",
1092                 "instanceType": "3" })
1093             self.fail()
1094         except LdbError as e52:
1095             (num, _) = e52.args
1096             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1097         delete_force(self.ldb, "cn=ldaptestuser2,cn=users," + self.base_dn)
1098
1099     def test_distinguished_name(self):
1100         """Tests the 'distinguishedName' attribute"""
1101         # The "dn" shortcut isn't supported
1102         m = Message()
1103         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1104         m["objectClass"] = MessageElement("group", 0, "objectClass")
1105         m["dn"] = MessageElement("cn=ldaptestgroup,cn=users," + self.base_dn, 0,
1106           "dn")
1107         try:
1108             ldb.add(m)
1109             self.fail()
1110         except LdbError as e53:
1111             (num, _) = e53.args
1112             self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
1113
1114         # a wrong "distinguishedName" attribute is obviously tolerated
1115         self.ldb.add({
1116               "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
1117               "objectclass": "group",
1118               "distinguishedName": "cn=ldaptest,cn=users," + self.base_dn})
1119
1120         # proof if the DN has been set correctly
1121         res = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
1122                          scope=SCOPE_BASE, attrs=["distinguishedName"])
1123         self.assertTrue(len(res) == 1)
1124         self.assertTrue("distinguishedName" in res[0])
1125         self.assertTrue(Dn(ldb, res[0]["distinguishedName"][0])
1126            == Dn(ldb, "cn=ldaptestgroup, cn=users," + self.base_dn))
1127
1128         # The "dn" shortcut isn't supported
1129         m = Message()
1130         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1131         m["dn"] = MessageElement(
1132           "cn=ldaptestgroup,cn=users," + self.base_dn, FLAG_MOD_REPLACE,
1133           "dn")
1134         try:
1135             ldb.modify(m)
1136             self.fail()
1137         except LdbError as e54:
1138             (num, _) = e54.args
1139             self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
1140
1141         m = Message()
1142         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1143         m["distinguishedName"] = MessageElement(
1144           "cn=ldaptestuser,cn=users," + self.base_dn, FLAG_MOD_ADD,
1145           "distinguishedName")
1146
1147         try:
1148             ldb.modify(m)
1149             self.fail()
1150         except LdbError as e55:
1151             (num, _) = e55.args
1152             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1153
1154         m = Message()
1155         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1156         m["distinguishedName"] = MessageElement(
1157           "cn=ldaptestuser,cn=users," + self.base_dn, FLAG_MOD_REPLACE,
1158           "distinguishedName")
1159
1160         try:
1161             ldb.modify(m)
1162             self.fail()
1163         except LdbError as e56:
1164             (num, _) = e56.args
1165             self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
1166
1167         m = Message()
1168         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1169         m["distinguishedName"] = MessageElement(
1170           "cn=ldaptestuser,cn=users," + self.base_dn, FLAG_MOD_DELETE,
1171           "distinguishedName")
1172
1173         try:
1174             ldb.modify(m)
1175             self.fail()
1176         except LdbError as e57:
1177             (num, _) = e57.args
1178             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1179
1180         delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1181
1182     def test_rdn_name(self):
1183         """Tests the RDN"""
1184         # Search
1185
1186         # empty RDN
1187         try:
1188             self.ldb.search("=,cn=users," + self.base_dn, scope=SCOPE_BASE)
1189             self.fail()
1190         except LdbError as e58:
1191             (num, _) = e58.args
1192             self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
1193
1194         # empty RDN name
1195         try:
1196             self.ldb.search("cn=,cn=users," + self.base_dn, scope=SCOPE_BASE)
1197             self.fail()
1198         except LdbError as e59:
1199             (num, _) = e59.args
1200             self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
1201
1202         try:
1203             self.ldb.search("=ldaptestgroup,cn=users," + self.base_dn, scope=SCOPE_BASE)
1204             self.fail()
1205         except LdbError as e60:
1206             (num, _) = e60.args
1207             self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
1208
1209         # Add
1210
1211         # empty RDN
1212         try:
1213             self.ldb.add({
1214                  "dn": "=,cn=users," + self.base_dn,
1215                  "objectclass": "group"})
1216             self.fail()
1217         except LdbError as e61:
1218             (num, _) = e61.args
1219             self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
1220
1221         # empty RDN name
1222         try:
1223             self.ldb.add({
1224                  "dn": "=ldaptestgroup,cn=users," + self.base_dn,
1225                  "objectclass": "group"})
1226             self.fail()
1227         except LdbError as e62:
1228             (num, _) = e62.args
1229             self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
1230
1231         # empty RDN value
1232         try:
1233             self.ldb.add({
1234                  "dn": "cn=,cn=users," + self.base_dn,
1235                  "objectclass": "group"})
1236             self.fail()
1237         except LdbError as e63:
1238             (num, _) = e63.args
1239             self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
1240
1241         # a wrong RDN candidate
1242         try:
1243             self.ldb.add({
1244                  "dn": "description=xyz,cn=users," + self.base_dn,
1245                  "objectclass": "group"})
1246             self.fail()
1247         except LdbError as e64:
1248             (num, _) = e64.args
1249             self.assertEquals(num, ERR_NAMING_VIOLATION)
1250
1251         delete_force(self.ldb, "description=xyz,cn=users," + self.base_dn)
1252
1253         # a wrong "name" attribute is obviously tolerated
1254         self.ldb.add({
1255              "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
1256              "objectclass": "group",
1257              "name": "ldaptestgroupx"})
1258
1259         # proof if the name has been set correctly
1260         res = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
1261                          scope=SCOPE_BASE, attrs=["name"])
1262         self.assertTrue(len(res) == 1)
1263         self.assertTrue("name" in res[0])
1264         self.assertTrue(res[0]["name"][0] == "ldaptestgroup")
1265
1266         # Modify
1267
1268         # empty RDN value
1269         m = Message()
1270         m.dn = Dn(ldb, "cn=,cn=users," + self.base_dn)
1271         m["description"] = "test"
1272         try:
1273             self.ldb.modify(m)
1274             self.fail()
1275         except LdbError as e65:
1276             (num, _) = e65.args
1277             self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
1278
1279         # Delete
1280
1281         # empty RDN value
1282         try:
1283             self.ldb.delete("cn=,cn=users," + self.base_dn)
1284             self.fail()
1285         except LdbError as e66:
1286             (num, _) = e66.args
1287             self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
1288
1289         # Rename
1290
1291         # new empty RDN
1292         try:
1293             self.ldb.rename("cn=ldaptestgroup,cn=users," + self.base_dn,
1294                             "=,cn=users," + self.base_dn)
1295             self.fail()
1296         except LdbError as e67:
1297             (num, _) = e67.args
1298             self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
1299
1300         # new empty RDN name
1301         try:
1302             self.ldb.rename("cn=ldaptestgroup,cn=users," + self.base_dn,
1303                             "=ldaptestgroup,cn=users," + self.base_dn)
1304             self.fail()
1305         except LdbError as e68:
1306             (num, _) = e68.args
1307             self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
1308
1309         # new empty RDN value
1310         try:
1311             self.ldb.rename("cn=ldaptestgroup,cn=users," + self.base_dn,
1312                             "cn=,cn=users," + self.base_dn)
1313             self.fail()
1314         except LdbError as e69:
1315             (num, _) = e69.args
1316             self.assertEquals(num, ERR_NAMING_VIOLATION)
1317
1318         # new wrong RDN candidate
1319         try:
1320             self.ldb.rename("cn=ldaptestgroup,cn=users," + self.base_dn,
1321                             "description=xyz,cn=users," + self.base_dn)
1322             self.fail()
1323         except LdbError as e70:
1324             (num, _) = e70.args
1325             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1326
1327         delete_force(self.ldb, "description=xyz,cn=users," + self.base_dn)
1328
1329         # old empty RDN value
1330         try:
1331             self.ldb.rename("cn=,cn=users," + self.base_dn,
1332                             "cn=ldaptestgroup,cn=users," + self.base_dn)
1333             self.fail()
1334         except LdbError as e71:
1335             (num, _) = e71.args
1336             self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
1337
1338         # names
1339
1340         m = Message()
1341         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1342         m["name"] = MessageElement("cn=ldaptestuser", FLAG_MOD_REPLACE,
1343           "name")
1344         try:
1345             ldb.modify(m)
1346             self.fail()
1347         except LdbError as e72:
1348             (num, _) = e72.args
1349             self.assertEquals(num, ERR_NOT_ALLOWED_ON_RDN)
1350
1351         m = Message()
1352         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1353         m["cn"] = MessageElement("ldaptestuser",
1354           FLAG_MOD_REPLACE, "cn")
1355         try:
1356             ldb.modify(m)
1357             self.fail()
1358         except LdbError as e73:
1359             (num, _) = e73.args
1360             self.assertEquals(num, ERR_NOT_ALLOWED_ON_RDN)
1361
1362         delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1363
1364
1365         # this test needs to be disabled until we really understand
1366         # what the rDN length constraints are
1367     def DISABLED_test_largeRDN(self):
1368         """Testing large rDN (limit 64 characters)"""
1369         rdn = "CN=a012345678901234567890123456789012345678901234567890123456789012"
1370         delete_force(self.ldb, "%s,%s" % (rdn, self.base_dn))
1371         ldif = """
1372 dn: %s,%s""" % (rdn,self.base_dn) + """
1373 objectClass: container
1374 """
1375         self.ldb.add_ldif(ldif)
1376         delete_force(self.ldb, "%s,%s" % (rdn, self.base_dn))
1377
1378         rdn = "CN=a0123456789012345678901234567890123456789012345678901234567890120"
1379         delete_force(self.ldb, "%s,%s" % (rdn, self.base_dn))
1380         try:
1381             ldif = """
1382 dn: %s,%s""" % (rdn,self.base_dn) + """
1383 objectClass: container
1384 """
1385             self.ldb.add_ldif(ldif)
1386             self.fail()
1387         except LdbError as e74:
1388             (num, _) = e74.args
1389             self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
1390         delete_force(self.ldb, "%s,%s" % (rdn, self.base_dn))
1391
1392     def test_rename(self):
1393         """Tests the rename operation"""
1394         try:
1395             # cannot rename to be a child of itself
1396             ldb.rename(self.base_dn, "dc=test," + self.base_dn)
1397             self.fail()
1398         except LdbError as e75:
1399             (num, _) = e75.args
1400             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1401
1402         try:
1403             # inexistent object
1404             ldb.rename("cn=ldaptestuser2,cn=users," + self.base_dn, "cn=ldaptestuser2,cn=users," + self.base_dn)
1405             self.fail()
1406         except LdbError as e76:
1407             (num, _) = e76.args
1408             self.assertEquals(num, ERR_NO_SUCH_OBJECT)
1409
1410         self.ldb.add({
1411              "dn": "cn=ldaptestuser2,cn=users," + self.base_dn,
1412              "objectclass": "user" })
1413
1414         ldb.rename("cn=ldaptestuser2,cn=users," + self.base_dn, "cn=ldaptestuser2,cn=users," + self.base_dn)
1415         ldb.rename("cn=ldaptestuser2,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=users," + self.base_dn)
1416         ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestUSER3,cn=users," + self.base_dn)
1417
1418         try:
1419             # containment problem: a user entry cannot contain user entries
1420             ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser4,cn=ldaptestuser3,cn=users," + self.base_dn)
1421             self.fail()
1422         except LdbError as e77:
1423             (num, _) = e77.args
1424             self.assertEquals(num, ERR_NAMING_VIOLATION)
1425
1426         try:
1427             # invalid parent
1428             ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=people,cn=users," + self.base_dn)
1429             self.fail()
1430         except LdbError as e78:
1431             (num, _) = e78.args
1432             self.assertEquals(num, ERR_OTHER)
1433
1434         try:
1435             # invalid target DN syntax
1436             ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, ",cn=users," + self.base_dn)
1437             self.fail()
1438         except LdbError as e79:
1439             (num, _) = e79.args
1440             self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
1441
1442         try:
1443             # invalid RDN name
1444             ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "ou=ldaptestuser3,cn=users," + self.base_dn)
1445             self.fail()
1446         except LdbError as e80:
1447             (num, _) = e80.args
1448             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1449
1450         delete_force(self.ldb, "cn=ldaptestuser3,cn=users," + self.base_dn)
1451
1452         # Performs some "systemFlags" testing
1453
1454         # Move failing since no "SYSTEM_FLAG_CONFIG_ALLOW_MOVE"
1455         try:
1456             ldb.rename("CN=DisplaySpecifiers," + self.configuration_dn, "CN=DisplaySpecifiers,CN=Services," + self.configuration_dn)
1457             self.fail()
1458         except LdbError as e81:
1459             (num, _) = e81.args
1460             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1461
1462         # Limited move failing since no "SYSTEM_FLAG_CONFIG_ALLOW_LIMITED_MOVE"
1463         try:
1464             ldb.rename("CN=Directory Service,CN=Windows NT,CN=Services," + self.configuration_dn, "CN=Directory Service,CN=RRAS,CN=Services," + self.configuration_dn)
1465             self.fail()
1466         except LdbError as e82:
1467             (num, _) = e82.args
1468             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1469
1470         # Rename failing since no "SYSTEM_FLAG_CONFIG_ALLOW_RENAME"
1471         try:
1472             ldb.rename("CN=DisplaySpecifiers," + self.configuration_dn, "CN=DisplaySpecifiers2," + self.configuration_dn)
1473             self.fail()
1474         except LdbError as e83:
1475             (num, _) = e83.args
1476             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1477
1478         # It's not really possible to test moves on the schema partition since
1479         # there don't exist subcontainers on it.
1480
1481         # Rename failing since "SYSTEM_FLAG_SCHEMA_BASE_OBJECT"
1482         try:
1483             ldb.rename("CN=Top," + self.schema_dn, "CN=Top2," + self.schema_dn)
1484             self.fail()
1485         except LdbError as e84:
1486             (num, _) = e84.args
1487             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1488
1489         # Move failing since "SYSTEM_FLAG_DOMAIN_DISALLOW_MOVE"
1490         try:
1491             ldb.rename("CN=Users," + self.base_dn, "CN=Users,CN=Computers," + self.base_dn)
1492             self.fail()
1493         except LdbError as e85:
1494             (num, _) = e85.args
1495             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1496
1497         # Rename failing since "SYSTEM_FLAG_DOMAIN_DISALLOW_RENAME"
1498         try:
1499             ldb.rename("CN=Users," + self.base_dn, "CN=Users2," + self.base_dn)
1500             self.fail()
1501         except LdbError as e86:
1502             (num, _) = e86.args
1503             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1504
1505         # Performs some other constraints testing
1506
1507         try:
1508             ldb.rename("CN=Policies,CN=System," + self.base_dn, "CN=Users2," + self.base_dn)
1509             self.fail()
1510         except LdbError as e87:
1511             (num, _) = e87.args
1512             self.assertEquals(num, ERR_OTHER)
1513
1514     def test_rename_twice(self):
1515         """Tests the rename operation twice - this corresponds to a past bug"""
1516         self.ldb.add({
1517              "dn": "cn=ldaptestuser5,cn=users," + self.base_dn,
1518              "objectclass": "user" })
1519
1520         ldb.rename("cn=ldaptestuser5,cn=users," + self.base_dn, "cn=ldaptestUSER5,cn=users," + self.base_dn)
1521         delete_force(self.ldb, "cn=ldaptestuser5,cn=users," + self.base_dn)
1522         self.ldb.add({
1523              "dn": "cn=ldaptestuser5,cn=users," + self.base_dn,
1524              "objectclass": "user" })
1525         ldb.rename("cn=ldaptestuser5,cn=Users," + self.base_dn, "cn=ldaptestUSER5,cn=users," + self.base_dn)
1526         res = ldb.search(expression="cn=ldaptestuser5")
1527         self.assertEquals(len(res), 1, "Wrong number of hits for cn=ldaptestuser5")
1528         res = ldb.search(expression="(&(cn=ldaptestuser5)(objectclass=user))")
1529         self.assertEquals(len(res), 1, "Wrong number of hits for (&(cn=ldaptestuser5)(objectclass=user))")
1530         delete_force(self.ldb, "cn=ldaptestuser5,cn=users," + self.base_dn)
1531
1532     def test_objectGUID(self):
1533         """Test objectGUID behaviour"""
1534         # The objectGUID cannot directly be set
1535         try:
1536             self.ldb.add_ldif("""
1537 dn: cn=ldaptestcontainer,""" + self.base_dn + """
1538 objectClass: container
1539 objectGUID: bd3480c9-58af-4cd8-92df-bc4a18b6e44d
1540 """)
1541             self.fail()
1542         except LdbError as e88:
1543             (num, _) = e88.args
1544             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1545
1546         self.ldb.add({
1547             "dn": "cn=ldaptestcontainer," + self.base_dn,
1548             "objectClass": "container" })
1549
1550         # The objectGUID cannot directly be changed
1551         try:
1552             self.ldb.modify_ldif("""
1553 dn: cn=ldaptestcontainer,""" + self.base_dn + """
1554 changetype: modify
1555 replace: objectGUID
1556 objectGUID: bd3480c9-58af-4cd8-92df-bc4a18b6e44d
1557 """)
1558             self.fail()
1559         except LdbError as e89:
1560             (num, _) = e89.args
1561             self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
1562
1563         delete_force(self.ldb, "cn=ldaptestcontainer," + self.base_dn)
1564
1565     def test_parentGUID(self):
1566         """Test parentGUID behaviour"""
1567         self.ldb.add({
1568             "dn": "cn=parentguidtest,cn=users," + self.base_dn,
1569             "objectclass":"user",
1570             "samaccountname":"parentguidtest"})
1571         res1 = ldb.search(base="cn=parentguidtest,cn=users," + self.base_dn, scope=SCOPE_BASE,
1572                           attrs=["parentGUID", "samaccountname"])
1573         res2 = ldb.search(base="cn=users," + self.base_dn,scope=SCOPE_BASE,
1574                           attrs=["objectGUID"])
1575         res3 = ldb.search(base=self.base_dn, scope=SCOPE_BASE,
1576                           attrs=["parentGUID"])
1577         res4 = ldb.search(base=self.configuration_dn, scope=SCOPE_BASE,
1578                           attrs=["parentGUID"])
1579         res5 = ldb.search(base=self.schema_dn, scope=SCOPE_BASE,
1580                           attrs=["parentGUID"])
1581
1582         """Check if the parentGUID is valid """
1583         self.assertEquals(res1[0]["parentGUID"], res2[0]["objectGUID"])
1584
1585         """Check if it returns nothing when there is no parent object - default NC"""
1586         has_parentGUID = False
1587         for key in res3[0].keys():
1588             if key == "parentGUID":
1589                 has_parentGUID = True
1590                 break
1591         self.assertFalse(has_parentGUID)
1592
1593         """Check if it returns nothing when there is no parent object - configuration NC"""
1594         has_parentGUID = False
1595         for key in res4[0].keys():
1596             if key == "parentGUID":
1597                 has_parentGUID = True
1598                 break
1599         self.assertFalse(has_parentGUID)
1600
1601         """Check if it returns nothing when there is no parent object - schema NC"""
1602         has_parentGUID = False
1603         for key in res5[0].keys():
1604             if key == "parentGUID":
1605                 has_parentGUID = True
1606                 break
1607         self.assertFalse(has_parentGUID)
1608
1609         """Ensures that if you look for another object attribute after the constructed
1610             parentGUID, it will return correctly"""
1611         has_another_attribute = False
1612         for key in res1[0].keys():
1613             if key == "sAMAccountName":
1614                 has_another_attribute = True
1615                 break
1616         self.assertTrue(has_another_attribute)
1617         self.assertTrue(len(res1[0]["samaccountname"]) == 1)
1618         self.assertEquals(res1[0]["samaccountname"][0], "parentguidtest")
1619
1620         # Testing parentGUID behaviour on rename\
1621
1622         self.ldb.add({
1623             "dn": "cn=testotherusers," + self.base_dn,
1624             "objectclass":"container"})
1625         res1 = ldb.search(base="cn=testotherusers," + self.base_dn,scope=SCOPE_BASE,
1626                           attrs=["objectGUID"])
1627         ldb.rename("cn=parentguidtest,cn=users," + self.base_dn,
1628                    "cn=parentguidtest,cn=testotherusers," + self.base_dn)
1629         res2 = ldb.search(base="cn=parentguidtest,cn=testotherusers," + self.base_dn,
1630                           scope=SCOPE_BASE,
1631                           attrs=["parentGUID"])
1632         self.assertEquals(res1[0]["objectGUID"], res2[0]["parentGUID"])
1633
1634         delete_force(self.ldb, "cn=parentguidtest,cn=testotherusers," + self.base_dn)
1635         delete_force(self.ldb, "cn=testotherusers," + self.base_dn)
1636
1637     def test_usnChanged(self):
1638         """Test usnChanged behaviour"""
1639
1640         self.ldb.add({
1641             "dn": "cn=ldaptestcontainer," + self.base_dn,
1642             "objectClass": "container" })
1643
1644         res = ldb.search("cn=ldaptestcontainer," + self.base_dn,
1645                          scope=SCOPE_BASE,
1646                          attrs=["objectGUID", "uSNCreated", "uSNChanged", "whenCreated", "whenChanged", "description"])
1647         self.assertTrue(len(res) == 1)
1648         self.assertFalse("description" in res[0])
1649         self.assertTrue("objectGUID" in res[0])
1650         self.assertTrue("uSNCreated" in res[0])
1651         self.assertTrue("uSNChanged" in res[0])
1652         self.assertTrue("whenCreated" in res[0])
1653         self.assertTrue("whenChanged" in res[0])
1654
1655         delete_force(self.ldb, "cn=ldaptestcontainer," + self.base_dn)
1656
1657         # All this attributes are specificable on add operations
1658         self.ldb.add({
1659             "dn": "cn=ldaptestcontainer," + self.base_dn,
1660             "objectclass": "container",
1661             "uSNCreated" : "1",
1662             "uSNChanged" : "1",
1663             "whenCreated": timestring(long(time.time())),
1664             "whenChanged": timestring(long(time.time())) })
1665
1666         res = ldb.search("cn=ldaptestcontainer," + self.base_dn,
1667                          scope=SCOPE_BASE,
1668                          attrs=["objectGUID", "uSNCreated", "uSNChanged", "whenCreated", "whenChanged", "description"])
1669         self.assertTrue(len(res) == 1)
1670         self.assertFalse("description" in res[0])
1671         self.assertTrue("objectGUID" in res[0])
1672         self.assertTrue("uSNCreated" in res[0])
1673         self.assertFalse(res[0]["uSNCreated"][0] == "1") # these are corrected
1674         self.assertTrue("uSNChanged" in res[0])
1675         self.assertFalse(res[0]["uSNChanged"][0] == "1") # these are corrected
1676         self.assertTrue("whenCreated" in res[0])
1677         self.assertTrue("whenChanged" in res[0])
1678
1679         ldb.modify_ldif("""
1680 dn: cn=ldaptestcontainer,""" + self.base_dn + """
1681 changetype: modify
1682 replace: description
1683 """)
1684
1685         res2 = ldb.search("cn=ldaptestcontainer," + self.base_dn,
1686                          scope=SCOPE_BASE,
1687                          attrs=["uSNCreated", "uSNChanged", "description"])
1688         self.assertTrue(len(res) == 1)
1689         self.assertFalse("description" in res2[0])
1690         self.assertEqual(res[0]["usnCreated"], res2[0]["usnCreated"])
1691         self.assertEqual(res[0]["usnCreated"], res2[0]["usnChanged"])
1692         self.assertEqual(res[0]["usnChanged"], res2[0]["usnChanged"])
1693
1694         ldb.modify_ldif("""
1695 dn: cn=ldaptestcontainer,""" + self.base_dn + """
1696 changetype: modify
1697 replace: description
1698 description: test
1699 """)
1700
1701         res3 = ldb.search("cn=ldaptestcontainer," + self.base_dn,
1702                          scope=SCOPE_BASE,
1703                          attrs=["uSNCreated", "uSNChanged", "description"])
1704         self.assertTrue(len(res) == 1)
1705         self.assertTrue("description" in res3[0])
1706         self.assertEqual("test", str(res3[0]["description"][0]))
1707         self.assertEqual(res[0]["usnCreated"], res3[0]["usnCreated"])
1708         self.assertNotEqual(res[0]["usnCreated"], res3[0]["usnChanged"])
1709         self.assertNotEqual(res[0]["usnChanged"], res3[0]["usnChanged"])
1710
1711         ldb.modify_ldif("""
1712 dn: cn=ldaptestcontainer,""" + self.base_dn + """
1713 changetype: modify
1714 replace: description
1715 description: test
1716 """)
1717
1718         res4 = ldb.search("cn=ldaptestcontainer," + self.base_dn,
1719                          scope=SCOPE_BASE,
1720                          attrs=["uSNCreated", "uSNChanged", "description"])
1721         self.assertTrue(len(res) == 1)
1722         self.assertTrue("description" in res4[0])
1723         self.assertEqual("test", str(res4[0]["description"][0]))
1724         self.assertEqual(res[0]["usnCreated"], res4[0]["usnCreated"])
1725         self.assertNotEqual(res3[0]["usnCreated"], res4[0]["usnChanged"])
1726         self.assertEqual(res3[0]["usnChanged"], res4[0]["usnChanged"])
1727
1728         ldb.modify_ldif("""
1729 dn: cn=ldaptestcontainer,""" + self.base_dn + """
1730 changetype: modify
1731 replace: description
1732 description: test2
1733 """)
1734
1735         res5 = ldb.search("cn=ldaptestcontainer," + self.base_dn,
1736                          scope=SCOPE_BASE,
1737                          attrs=["uSNCreated", "uSNChanged", "description"])
1738         self.assertTrue(len(res) == 1)
1739         self.assertTrue("description" in res5[0])
1740         self.assertEqual("test2", str(res5[0]["description"][0]))
1741         self.assertEqual(res[0]["usnCreated"], res5[0]["usnCreated"])
1742         self.assertNotEqual(res3[0]["usnChanged"], res5[0]["usnChanged"])
1743
1744         ldb.modify_ldif("""
1745 dn: cn=ldaptestcontainer,""" + self.base_dn + """
1746 changetype: modify
1747 delete: description
1748 description: test2
1749 """)
1750
1751         res6 = ldb.search("cn=ldaptestcontainer," + self.base_dn,
1752                          scope=SCOPE_BASE,
1753                          attrs=["uSNCreated", "uSNChanged", "description"])
1754         self.assertTrue(len(res) == 1)
1755         self.assertFalse("description" in res6[0])
1756         self.assertEqual(res[0]["usnCreated"], res6[0]["usnCreated"])
1757         self.assertNotEqual(res5[0]["usnChanged"], res6[0]["usnChanged"])
1758
1759         ldb.modify_ldif("""
1760 dn: cn=ldaptestcontainer,""" + self.base_dn + """
1761 changetype: modify
1762 add: description
1763 description: test3
1764 """)
1765
1766         res7 = ldb.search("cn=ldaptestcontainer," + self.base_dn,
1767                          scope=SCOPE_BASE,
1768                          attrs=["uSNCreated", "uSNChanged", "description"])
1769         self.assertTrue(len(res) == 1)
1770         self.assertTrue("description" in res7[0])
1771         self.assertEqual("test3", str(res7[0]["description"][0]))
1772         self.assertEqual(res[0]["usnCreated"], res7[0]["usnCreated"])
1773         self.assertNotEqual(res6[0]["usnChanged"], res7[0]["usnChanged"])
1774
1775         ldb.modify_ldif("""
1776 dn: cn=ldaptestcontainer,""" + self.base_dn + """
1777 changetype: modify
1778 delete: description
1779 """)
1780
1781         res8 = ldb.search("cn=ldaptestcontainer," + self.base_dn,
1782                          scope=SCOPE_BASE,
1783                          attrs=["uSNCreated", "uSNChanged", "description"])
1784         self.assertTrue(len(res) == 1)
1785         self.assertFalse("description" in res8[0])
1786         self.assertEqual(res[0]["usnCreated"], res8[0]["usnCreated"])
1787         self.assertNotEqual(res7[0]["usnChanged"], res8[0]["usnChanged"])
1788
1789         delete_force(self.ldb, "cn=ldaptestcontainer," + self.base_dn)
1790
1791     def test_groupType_int32(self):
1792         """Test groupType (int32) behaviour (should appear to be casted to a 32 bit signed integer before comparsion)"""
1793
1794         res1 = ldb.search(base=self.base_dn, scope=SCOPE_SUBTREE,
1795                           attrs=["groupType"], expression="groupType=2147483653")
1796
1797         res2 = ldb.search(base=self.base_dn, scope=SCOPE_SUBTREE,
1798                           attrs=["groupType"], expression="groupType=-2147483643")
1799
1800         self.assertEquals(len(res1), len(res2))
1801
1802         self.assertTrue(res1.count > 0)
1803
1804         self.assertEquals(res1[0]["groupType"][0], "-2147483643")
1805
1806     def test_linked_attributes(self):
1807         """This tests the linked attribute behaviour"""
1808
1809         ldb.add({
1810             "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
1811             "objectclass": "group"})
1812
1813         # This should not work since "memberOf" is linked to "member"
1814         try:
1815             ldb.add({
1816                 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
1817                 "objectclass": "user",
1818                 "memberOf": "cn=ldaptestgroup,cn=users," + self.base_dn})
1819         except LdbError as e90:
1820             (num, _) = e90.args
1821             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1822
1823         ldb.add({
1824             "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
1825             "objectclass": "user"})
1826
1827         m = Message()
1828         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1829         m["memberOf"] = MessageElement("cn=ldaptestgroup,cn=users," + self.base_dn,
1830           FLAG_MOD_ADD, "memberOf")
1831         try:
1832             ldb.modify(m)
1833             self.fail()
1834         except LdbError as e91:
1835             (num, _) = e91.args
1836             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1837
1838         m = Message()
1839         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1840         m["member"] = MessageElement("cn=ldaptestuser,cn=users," + self.base_dn,
1841           FLAG_MOD_ADD, "member")
1842         ldb.modify(m)
1843
1844         m = Message()
1845         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1846         m["memberOf"] = MessageElement("cn=ldaptestgroup,cn=users," + self.base_dn,
1847           FLAG_MOD_REPLACE, "memberOf")
1848         try:
1849             ldb.modify(m)
1850             self.fail()
1851         except LdbError as e92:
1852             (num, _) = e92.args
1853             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1854
1855         m = Message()
1856         m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1857         m["memberOf"] = MessageElement("cn=ldaptestgroup,cn=users," + self.base_dn,
1858           FLAG_MOD_DELETE, "memberOf")
1859         try:
1860             ldb.modify(m)
1861             self.fail()
1862         except LdbError as e93:
1863             (num, _) = e93.args
1864             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1865
1866         m = Message()
1867         m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1868         m["member"] = MessageElement("cn=ldaptestuser,cn=users," + self.base_dn,
1869           FLAG_MOD_DELETE, "member")
1870         ldb.modify(m)
1871
1872         # This should yield no results since the member attribute for
1873         # "ldaptestuser" should have been deleted
1874         res1 = ldb.search("cn=ldaptestgroup, cn=users," + self.base_dn,
1875                           scope=SCOPE_BASE,
1876                           expression="(member=cn=ldaptestuser,cn=users," + self.base_dn + ")",
1877                           attrs=[])
1878         self.assertTrue(len(res1) == 0)
1879
1880         delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1881
1882         ldb.add({
1883             "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
1884             "objectclass": "group",
1885             "member": "cn=ldaptestuser,cn=users," + self.base_dn})
1886
1887         delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1888
1889         # Make sure that the "member" attribute for "ldaptestuser" has been
1890         # removed
1891         res = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
1892                           scope=SCOPE_BASE, attrs=["member"])
1893         self.assertTrue(len(res) == 1)
1894         self.assertFalse("member" in res[0])
1895
1896         delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1897
1898     def test_wkguid(self):
1899         """Test Well known GUID behaviours (including DN+Binary)"""
1900
1901         res = self.ldb.search(base=("<WKGUID=ab1d30f3768811d1aded00c04fd8d5cd,%s>" % self.base_dn), scope=SCOPE_BASE, attrs=[])
1902         self.assertEquals(len(res), 1)
1903
1904         res2 = self.ldb.search(scope=SCOPE_BASE, attrs=["wellKnownObjects"], expression=("wellKnownObjects=B:32:ab1d30f3768811d1aded00c04fd8d5cd:%s" % res[0].dn))
1905         self.assertEquals(len(res2), 1)
1906
1907         # Prove that the matching rule is over the whole DN+Binary
1908         res2 = self.ldb.search(scope=SCOPE_BASE, attrs=["wellKnownObjects"], expression=("wellKnownObjects=B:32:ab1d30f3768811d1aded00c04fd8d5cd"))
1909         self.assertEquals(len(res2), 0)
1910         # Prove that the matching rule is over the whole DN+Binary
1911         res2 = self.ldb.search(scope=SCOPE_BASE, attrs=["wellKnownObjects"], expression=("wellKnownObjects=%s") % res[0].dn)
1912         self.assertEquals(len(res2), 0)
1913
1914     def test_subschemasubentry(self):
1915         """Test subSchemaSubEntry appears when requested, but not when not requested"""
1916
1917         res = self.ldb.search(base=self.base_dn, scope=SCOPE_BASE, attrs=["subSchemaSubEntry"])
1918         self.assertEquals(len(res), 1)
1919         self.assertEquals(res[0]["subSchemaSubEntry"][0], "CN=Aggregate,"+self.schema_dn)
1920
1921         res = self.ldb.search(base=self.base_dn, scope=SCOPE_BASE, attrs=["*"])
1922         self.assertEquals(len(res), 1)
1923         self.assertTrue("subScheamSubEntry" not in res[0])
1924
1925     def test_all(self):
1926         """Basic tests"""
1927
1928         # Testing user add
1929
1930         ldb.add({
1931             "dn": "cn=ldaptestuser,cn=uSers," + self.base_dn,
1932             "objectclass": "user",
1933             "cN": "LDAPtestUSER",
1934             "givenname": "ldap",
1935             "sn": "testy"})
1936
1937         ldb.add({
1938             "dn": "cn=ldaptestgroup,cn=uSers," + self.base_dn,
1939             "objectclass": "group",
1940             "member": "cn=ldaptestuser,cn=useRs," + self.base_dn})
1941
1942         ldb.add({
1943             "dn": "cn=ldaptestcomputer,cn=computers," + self.base_dn,
1944             "objectclass": "computer",
1945             "cN": "LDAPtestCOMPUTER"})
1946
1947         ldb.add({"dn": "cn=ldaptest2computer,cn=computers," + self.base_dn,
1948             "objectClass": "computer",
1949             "cn": "LDAPtest2COMPUTER",
1950             "userAccountControl": str(UF_WORKSTATION_TRUST_ACCOUNT),
1951             "displayname": "ldap testy"})
1952
1953         try:
1954             ldb.add({"dn": "cn=ldaptestcomputer3,cn=computers," + self.base_dn,
1955                      "objectClass": "computer",
1956                      "cn": "LDAPtest2COMPUTER"
1957                      })
1958             self.fail()
1959         except LdbError as e94:
1960             (num, _) = e94.args
1961             self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
1962
1963         try:
1964             ldb.add({"dn": "cn=ldaptestcomputer3,cn=computers," + self.base_dn,
1965                      "objectClass": "computer",
1966                      "cn": "ldaptestcomputer3",
1967                      "sAMAccountType": str(ATYPE_NORMAL_ACCOUNT)
1968                 })
1969             self.fail()
1970         except LdbError as e95:
1971             (num, _) = e95.args
1972             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1973
1974         ldb.add({"dn": "cn=ldaptestcomputer3,cn=computers," + self.base_dn,
1975                  "objectClass": "computer",
1976                  "cn": "LDAPtestCOMPUTER3"
1977                  })
1978
1979         # Testing ldb.search for (&(cn=ldaptestcomputer3)(objectClass=user))
1980         res = ldb.search(self.base_dn, expression="(&(cn=ldaptestcomputer3)(objectClass=user))")
1981         self.assertEquals(len(res), 1, "Found only %d for (&(cn=ldaptestcomputer3)(objectClass=user))" % len(res))
1982
1983         self.assertEquals(str(res[0].dn), ("CN=ldaptestcomputer3,CN=Computers," + self.base_dn))
1984         self.assertEquals(res[0]["cn"][0], "ldaptestcomputer3")
1985         self.assertEquals(res[0]["name"][0], "ldaptestcomputer3")
1986         self.assertEquals(res[0]["objectClass"][0], "top")
1987         self.assertEquals(res[0]["objectClass"][1], "person")
1988         self.assertEquals(res[0]["objectClass"][2], "organizationalPerson")
1989         self.assertEquals(res[0]["objectClass"][3], "user")
1990         self.assertEquals(res[0]["objectClass"][4], "computer")
1991         self.assertTrue("objectGUID" in res[0])
1992         self.assertTrue("whenCreated" in res[0])
1993         self.assertEquals(res[0]["objectCategory"][0], ("CN=Computer,%s" % ldb.get_schema_basedn()))
1994         self.assertEquals(int(res[0]["primaryGroupID"][0]), 513)
1995         self.assertEquals(int(res[0]["sAMAccountType"][0]), ATYPE_NORMAL_ACCOUNT)
1996         self.assertEquals(int(res[0]["userAccountControl"][0]), UF_NORMAL_ACCOUNT | UF_PASSWD_NOTREQD | UF_ACCOUNTDISABLE)
1997
1998         delete_force(self.ldb, "cn=ldaptestcomputer3,cn=computers," + self.base_dn)
1999
2000         # Testing attribute or value exists behaviour
2001         try:
2002             ldb.modify_ldif("""
2003 dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """
2004 changetype: modify
2005 replace: servicePrincipalName
2006 servicePrincipalName: host/ldaptest2computer
2007 servicePrincipalName: host/ldaptest2computer
2008 servicePrincipalName: cifs/ldaptest2computer
2009 """)
2010             self.fail()
2011         except LdbError as e96:
2012             (num, msg) = e96.args
2013             self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
2014
2015         ldb.modify_ldif("""
2016 dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """
2017 changetype: modify
2018 replace: servicePrincipalName
2019 servicePrincipalName: host/ldaptest2computer
2020 servicePrincipalName: cifs/ldaptest2computer
2021 """)
2022         try:
2023             ldb.modify_ldif("""
2024 dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """
2025 changetype: modify
2026 add: servicePrincipalName
2027 servicePrincipalName: host/ldaptest2computer
2028 """)
2029             self.fail()
2030         except LdbError as e97:
2031             (num, msg) = e97.args
2032             self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
2033
2034         # Testing ranged results
2035         ldb.modify_ldif("""
2036 dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """
2037 changetype: modify
2038 replace: servicePrincipalName
2039 """)
2040
2041         ldb.modify_ldif("""
2042 dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """
2043 changetype: modify
2044 add: servicePrincipalName
2045 servicePrincipalName: host/ldaptest2computer0
2046 servicePrincipalName: host/ldaptest2computer1
2047 servicePrincipalName: host/ldaptest2computer2
2048 servicePrincipalName: host/ldaptest2computer3
2049 servicePrincipalName: host/ldaptest2computer4
2050 servicePrincipalName: host/ldaptest2computer5
2051 servicePrincipalName: host/ldaptest2computer6
2052 servicePrincipalName: host/ldaptest2computer7
2053 servicePrincipalName: host/ldaptest2computer8
2054 servicePrincipalName: host/ldaptest2computer9
2055 servicePrincipalName: host/ldaptest2computer10
2056 servicePrincipalName: host/ldaptest2computer11
2057 servicePrincipalName: host/ldaptest2computer12
2058 servicePrincipalName: host/ldaptest2computer13
2059 servicePrincipalName: host/ldaptest2computer14
2060 servicePrincipalName: host/ldaptest2computer15
2061 servicePrincipalName: host/ldaptest2computer16
2062 servicePrincipalName: host/ldaptest2computer17
2063 servicePrincipalName: host/ldaptest2computer18
2064 servicePrincipalName: host/ldaptest2computer19
2065 servicePrincipalName: host/ldaptest2computer20
2066 servicePrincipalName: host/ldaptest2computer21
2067 servicePrincipalName: host/ldaptest2computer22
2068 servicePrincipalName: host/ldaptest2computer23
2069 servicePrincipalName: host/ldaptest2computer24
2070 servicePrincipalName: host/ldaptest2computer25
2071 servicePrincipalName: host/ldaptest2computer26
2072 servicePrincipalName: host/ldaptest2computer27
2073 servicePrincipalName: host/ldaptest2computer28
2074 servicePrincipalName: host/ldaptest2computer29
2075 """)
2076
2077         res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE,
2078                          attrs=["servicePrincipalName;range=0-*"])
2079         self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
2080         self.assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30)
2081
2082         res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-19"])
2083         self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
2084         self.assertEquals(len(res[0]["servicePrincipalName;range=0-19"]), 20)
2085
2086
2087         res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-30"])
2088         self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
2089         self.assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30)
2090
2091         res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-40"])
2092         self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
2093         self.assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30)
2094
2095         res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=30-40"])
2096         self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
2097         self.assertEquals(len(res[0]["servicePrincipalName;range=30-*"]), 0)
2098
2099
2100         res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=10-40"])
2101         self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
2102         self.assertEquals(len(res[0]["servicePrincipalName;range=10-*"]), 20)
2103         # pos_11 = res[0]["servicePrincipalName;range=10-*"][18]
2104
2105         res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=11-40"])
2106         self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
2107         self.assertEquals(len(res[0]["servicePrincipalName;range=11-*"]), 19)
2108             # self.assertEquals((res[0]["servicePrincipalName;range=11-*"][18]), pos_11)
2109
2110         res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=11-15"])
2111         self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
2112         self.assertEquals(len(res[0]["servicePrincipalName;range=11-15"]), 5)
2113             # self.assertEquals(res[0]["servicePrincipalName;range=11-15"][4], pos_11)
2114
2115         res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName"])
2116         self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
2117         self.assertEquals(len(res[0]["servicePrincipalName"]), 30)
2118             # self.assertEquals(res[0]["servicePrincipalName"][18], pos_11)
2119
2120         delete_force(self.ldb, "cn=ldaptestuser2,cn=users," + self.base_dn)
2121         ldb.add({
2122             "dn": "cn=ldaptestuser2,cn=useRs," + self.base_dn,
2123             "objectClass": "user",
2124             "cn": "LDAPtestUSER2",
2125             "givenname": "testy",
2126             "sn": "ldap user2"})
2127
2128         # Testing Ambigious Name Resolution
2129         # Testing ldb.search for (&(anr=ldap testy)(objectClass=user))
2130         res = ldb.search(expression="(&(anr=ldap testy)(objectClass=user))")
2131         self.assertEquals(len(res), 3, "Found only %d of 3 for (&(anr=ldap testy)(objectClass=user))" % len(res))
2132
2133         # Testing ldb.search for (&(anr=testy ldap)(objectClass=user))
2134         res = ldb.search(expression="(&(anr=testy ldap)(objectClass=user))")
2135         self.assertEquals(len(res), 2, "Found only %d of 2 for (&(anr=testy ldap)(objectClass=user))" % len(res))
2136
2137         # Testing ldb.search for (&(anr=ldap)(objectClass=user))
2138         res = ldb.search(expression="(&(anr=ldap)(objectClass=user))")
2139         self.assertEquals(len(res), 4, "Found only %d of 4 for (&(anr=ldap)(objectClass=user))" % len(res))
2140
2141         # Testing ldb.search for (&(anr==ldap)(objectClass=user))
2142         res = ldb.search(expression="(&(anr==ldap)(objectClass=user))")
2143         self.assertEquals(len(res), 1, "Could not find (&(anr==ldap)(objectClass=user)). Found only %d for (&(anr=ldap)(objectClass=user))" % len(res))
2144
2145         self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn))
2146         self.assertEquals(res[0]["cn"][0], "ldaptestuser")
2147         self.assertEquals(str(res[0]["name"]), "ldaptestuser")
2148
2149         # Testing ldb.search for (&(anr=testy)(objectClass=user))
2150         res = ldb.search(expression="(&(anr=testy)(objectClass=user))")
2151         self.assertEquals(len(res), 2, "Found only %d for (&(anr=testy)(objectClass=user))" % len(res))
2152
2153         # Testing ldb.search for (&(anr=testy ldap)(objectClass=user))
2154         res = ldb.search(expression="(&(anr=testy ldap)(objectClass=user))")
2155         self.assertEquals(len(res), 2, "Found only %d for (&(anr=testy ldap)(objectClass=user))" % len(res))
2156
2157         # Testing ldb.search for (&(anr==testy ldap)(objectClass=user))
2158 # this test disabled for the moment, as anr with == tests are not understood
2159 #        res = ldb.search(expression="(&(anr==testy ldap)(objectClass=user))")
2160 #        self.assertEquals(len(res), 1, "Found only %d for (&(anr==testy ldap)(objectClass=user))" % len(res))
2161
2162 #        self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn))
2163 #        self.assertEquals(res[0]["cn"][0], "ldaptestuser")
2164 #        self.assertEquals(res[0]["name"][0], "ldaptestuser")
2165
2166         # Testing ldb.search for (&(anr==testy ldap)(objectClass=user))
2167 #        res = ldb.search(expression="(&(anr==testy ldap)(objectClass=user))")
2168 #        self.assertEquals(len(res), 1, "Could not find (&(anr==testy ldap)(objectClass=user))")
2169
2170 #        self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn))
2171 #        self.assertEquals(res[0]["cn"][0], "ldaptestuser")
2172 #        self.assertEquals(res[0]["name"][0], "ldaptestuser")
2173
2174         # Testing ldb.search for (&(anr=testy ldap user)(objectClass=user))
2175         res = ldb.search(expression="(&(anr=testy ldap user)(objectClass=user))")
2176         self.assertEquals(len(res), 1, "Could not find (&(anr=testy ldap user)(objectClass=user))")
2177
2178         self.assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
2179         self.assertEquals(str(res[0]["cn"]), "ldaptestuser2")
2180         self.assertEquals(str(res[0]["name"]), "ldaptestuser2")
2181
2182         # Testing ldb.search for (&(anr==testy ldap user2)(objectClass=user))
2183 #        res = ldb.search(expression="(&(anr==testy ldap user2)(objectClass=user))")
2184 #        self.assertEquals(len(res), 1, "Could not find (&(anr==testy ldap user2)(objectClass=user))")
2185
2186         self.assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
2187         self.assertEquals(str(res[0]["cn"]), "ldaptestuser2")
2188         self.assertEquals(str(res[0]["name"]), "ldaptestuser2")
2189
2190         # Testing ldb.search for (&(anr==ldap user2)(objectClass=user))
2191 #        res = ldb.search(expression="(&(anr==ldap user2)(objectClass=user))")
2192 #        self.assertEquals(len(res), 1, "Could not find (&(anr==ldap user2)(objectClass=user))")
2193
2194         self.assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
2195         self.assertEquals(str(res[0]["cn"]), "ldaptestuser2")
2196         self.assertEquals(str(res[0]["name"]), "ldaptestuser2")
2197
2198         # Testing ldb.search for (&(anr==not ldap user2)(objectClass=user))
2199 #        res = ldb.search(expression="(&(anr==not ldap user2)(objectClass=user))")
2200 #        self.assertEquals(len(res), 0, "Must not find (&(anr==not ldap user2)(objectClass=user))")
2201
2202         # Testing ldb.search for (&(anr=not ldap user2)(objectClass=user))
2203         res = ldb.search(expression="(&(anr=not ldap user2)(objectClass=user))")
2204         self.assertEquals(len(res), 0, "Must not find (&(anr=not ldap user2)(objectClass=user))")
2205
2206         # Testing ldb.search for (&(anr="testy ldap")(objectClass=user)) (ie, with quotes)
2207 #        res = ldb.search(expression="(&(anr==\"testy ldap\")(objectClass=user))")
2208 #        self.assertEquals(len(res), 0, "Found (&(anr==\"testy ldap\")(objectClass=user))")
2209
2210         # Testing Renames
2211
2212         attrs = ["objectGUID", "objectSid"]
2213         # Testing ldb.search for (&(cn=ldaptestUSer2)(objectClass=user))
2214         res_user = ldb.search(self.base_dn, expression="(&(cn=ldaptestUSer2)(objectClass=user))", scope=SCOPE_SUBTREE, attrs=attrs)
2215         self.assertEquals(len(res_user), 1, "Could not find (&(cn=ldaptestUSer2)(objectClass=user))")
2216
2217         # Check rename works with extended/alternate DN forms
2218         ldb.rename("<SID=" + ldb.schema_format_value("objectSID", res_user[0]["objectSID"][0]) + ">" , "cn=ldaptestUSER3,cn=users," + self.base_dn)
2219
2220         # Testing ldb.search for (&(cn=ldaptestuser3)(objectClass=user))
2221         res = ldb.search(expression="(&(cn=ldaptestuser3)(objectClass=user))")
2222         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser3)(objectClass=user))")
2223
2224         self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
2225         self.assertEquals(str(res[0]["cn"]), "ldaptestUSER3")
2226         self.assertEquals(str(res[0]["name"]), "ldaptestUSER3")
2227
2228          #"Testing ldb.search for (&(&(cn=ldaptestuser3)(userAccountControl=*))(objectClass=user))"
2229         res = ldb.search(expression="(&(&(cn=ldaptestuser3)(userAccountControl=*))(objectClass=user))")
2230         self.assertEquals(len(res), 1, "(&(&(cn=ldaptestuser3)(userAccountControl=*))(objectClass=user))")
2231
2232         self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
2233         self.assertEquals(str(res[0]["cn"]), "ldaptestUSER3")
2234         self.assertEquals(str(res[0]["name"]), "ldaptestUSER3")
2235
2236          #"Testing ldb.search for (&(&(cn=ldaptestuser3)(userAccountControl=546))(objectClass=user))"
2237         res = ldb.search(expression="(&(&(cn=ldaptestuser3)(userAccountControl=546))(objectClass=user))")
2238         self.assertEquals(len(res), 1, "(&(&(cn=ldaptestuser3)(userAccountControl=546))(objectClass=user))")
2239
2240         self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
2241         self.assertEquals(str(res[0]["cn"]), "ldaptestUSER3")
2242         self.assertEquals(str(res[0]["name"]), "ldaptestUSER3")
2243
2244          #"Testing ldb.search for (&(&(cn=ldaptestuser3)(userAccountControl=547))(objectClass=user))"
2245         res = ldb.search(expression="(&(&(cn=ldaptestuser3)(userAccountControl=547))(objectClass=user))")
2246         self.assertEquals(len(res), 0, "(&(&(cn=ldaptestuser3)(userAccountControl=547))(objectClass=user))")
2247
2248         # Testing ldb.search for (dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ") - should not work
2249         res = ldb.search(expression="(dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")")
2250         self.assertEquals(len(res), 0, "Could find (dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")")
2251
2252         # Testing ldb.search for (distinguishedName=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")
2253         res = ldb.search(expression="(distinguishedName=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")")
2254         self.assertEquals(len(res), 1, "Could not find (distinguishedName=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")")
2255         self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
2256         self.assertEquals(str(res[0]["cn"]), "ldaptestUSER3")
2257         self.assertEquals(str(res[0]["name"]), "ldaptestUSER3")
2258
2259         # ensure we cannot add it again
2260         try:
2261             ldb.add({"dn": "cn=ldaptestuser3,cn=userS," + self.base_dn,
2262                       "objectClass": "user",
2263                       "cn": "LDAPtestUSER3"})
2264             self.fail()
2265         except LdbError as e98:
2266             (num, _) = e98.args
2267             self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
2268
2269         # rename back
2270         ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser2,cn=users," + self.base_dn)
2271
2272         # ensure we cannot rename it twice
2273         try:
2274             ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn,
2275                        "cn=ldaptestuser2,cn=users," + self.base_dn)
2276             self.fail()
2277         except LdbError as e99:
2278             (num, _) = e99.args
2279             self.assertEquals(num, ERR_NO_SUCH_OBJECT)
2280
2281         # ensure can now use that name
2282         ldb.add({"dn": "cn=ldaptestuser3,cn=users," + self.base_dn,
2283                       "objectClass": "user",
2284                       "cn": "LDAPtestUSER3"})
2285
2286         # ensure we now cannot rename
2287         try:
2288             ldb.rename("cn=ldaptestuser2,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=users," + self.base_dn)
2289             self.fail()
2290         except LdbError as e100:
2291             (num, _) = e100.args
2292             self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
2293         try:
2294             ldb.rename("cn=ldaptestuser3,cn=users,%s" % self.base_dn, "cn=ldaptestuser3,%s" % ldb.get_config_basedn())
2295             self.fail()
2296         except LdbError as e101:
2297             (num, _) = e101.args
2298             self.assertTrue(num in (71, 64))
2299
2300         ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser5,cn=users," + self.base_dn)
2301
2302         ldb.delete("cn=ldaptestuser5,cn=users," + self.base_dn)
2303
2304         delete_force(ldb, "cn=ldaptestgroup2,cn=users," + self.base_dn)
2305
2306         ldb.rename("cn=ldaptestgroup,cn=users," + self.base_dn, "cn=ldaptestgroup2,cn=users," + self.base_dn)
2307
2308         # Testing subtree renames
2309
2310         ldb.add({"dn": "cn=ldaptestcontainer," + self.base_dn,
2311                  "objectClass": "container"})
2312
2313         ldb.add({"dn": "CN=ldaptestuser4,CN=ldaptestcontainer," + self.base_dn,
2314                  "objectClass": "user",
2315                  "cn": "LDAPtestUSER4"})
2316
2317         # Here we don't enforce these hard "description" constraints
2318         ldb.modify_ldif("""
2319 dn: cn=ldaptestcontainer,""" + self.base_dn + """
2320 changetype: modify
2321 replace: description
2322 description: desc1
2323 description: desc2
2324 """)
2325
2326         ldb.modify_ldif("""
2327 dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
2328 changetype: modify
2329 add: member
2330 member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """
2331 member: cn=ldaptestcomputer,cn=computers,""" + self.base_dn + """
2332 member: cn=ldaptestuser2,cn=users,""" + self.base_dn + """
2333 """)
2334
2335         # Testing ldb.rename of cn=ldaptestcontainer," + self.base_dn + " to cn=ldaptestcontainer2," + self.base_dn
2336         ldb.rename("CN=ldaptestcontainer," + self.base_dn, "CN=ldaptestcontainer2," + self.base_dn)
2337
2338         # Testing ldb.search for (&(cn=ldaptestuser4)(objectClass=user))
2339         res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))")
2340         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser4)(objectClass=user))")
2341
2342         # Testing subtree ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + self.base_dn
2343         try:
2344             res = ldb.search("cn=ldaptestcontainer," + self.base_dn,
2345                     expression="(&(cn=ldaptestuser4)(objectClass=user))",
2346                     scope=SCOPE_SUBTREE)
2347             self.fail(res)
2348         except LdbError as e102:
2349             (num, _) = e102.args
2350             self.assertEquals(num, ERR_NO_SUCH_OBJECT)
2351
2352         # Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + self.base_dn
2353         try:
2354             res = ldb.search("cn=ldaptestcontainer," + self.base_dn,
2355                     expression="(&(cn=ldaptestuser4)(objectClass=user))", scope=SCOPE_ONELEVEL)
2356             self.fail()
2357         except LdbError as e103:
2358             (num, _) = e103.args
2359             self.assertEquals(num, ERR_NO_SUCH_OBJECT)
2360
2361         # Testing ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in renamed container"
2362         res = ldb.search("cn=ldaptestcontainer2," + self.base_dn, expression="(&(cn=ldaptestuser4)(objectClass=user))", scope=SCOPE_SUBTREE)
2363         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser4)(objectClass=user)) under cn=ldaptestcontainer2," + self.base_dn)
2364
2365         self.assertEquals(str(res[0].dn), ("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn))
2366         self.assertEquals(res[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
2367
2368         time.sleep(4)
2369
2370         # Testing ldb.search for (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group)) to check subtree renames and linked attributes"
2371         res = ldb.search(self.base_dn, expression="(&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group))", scope=SCOPE_SUBTREE)
2372         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?")
2373
2374         # Testing ldb.rename (into itself) of cn=ldaptestcontainer2," + self.base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer2," + self.base_dn
2375         try:
2376             ldb.rename("cn=ldaptestcontainer2," + self.base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer2," + self.base_dn)
2377             self.fail()
2378         except LdbError as e104:
2379             (num, _) = e104.args
2380             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
2381
2382         # Testing ldb.rename (into non-existent container) of cn=ldaptestcontainer2," + self.base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer3," + self.base_dn
2383         try:
2384             ldb.rename("cn=ldaptestcontainer2," + self.base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer3," + self.base_dn)
2385             self.fail()
2386         except LdbError as e105:
2387             (num, _) = e105.args
2388             self.assertTrue(num in (ERR_UNWILLING_TO_PERFORM, ERR_OTHER))
2389
2390         # Testing delete (should fail, not a leaf node) of renamed cn=ldaptestcontainer2," + self.base_dn
2391         try:
2392             ldb.delete("cn=ldaptestcontainer2," + self.base_dn)
2393             self.fail()
2394         except LdbError as e106:
2395             (num, _) = e106.args
2396             self.assertEquals(num, ERR_NOT_ALLOWED_ON_NON_LEAF)
2397
2398         # Testing base ldb.search for CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn
2399         res = ldb.search(expression="(objectclass=*)", base=("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn), scope=SCOPE_BASE)
2400         self.assertEquals(len(res), 1)
2401         res = ldb.search(expression="(cn=ldaptestuser40)", base=("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn), scope=SCOPE_BASE)
2402         self.assertEquals(len(res), 0)
2403
2404         # Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in cn=ldaptestcontainer2," + self.base_dn
2405         res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))", base=("cn=ldaptestcontainer2," + self.base_dn), scope=SCOPE_ONELEVEL)
2406         self.assertEquals(len(res), 1)
2407
2408         # Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in cn=ldaptestcontainer2," + self.base_dn
2409         res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))", base=("cn=ldaptestcontainer2," + self.base_dn), scope=SCOPE_SUBTREE)
2410         self.assertEquals(len(res), 1)
2411
2412         # Testing delete of subtree renamed "+("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn)
2413         ldb.delete(("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn))
2414         # Testing delete of renamed cn=ldaptestcontainer2," + self.base_dn
2415         ldb.delete("cn=ldaptestcontainer2," + self.base_dn)
2416
2417         ldb.add({"dn": "cn=ldaptestutf8user èùéìòà,cn=users," + self.base_dn, "objectClass": "user"})
2418
2419         ldb.add({"dn": "cn=ldaptestutf8user2  èùéìòà,cn=users," + self.base_dn, "objectClass": "user"})
2420
2421         # Testing ldb.search for (&(cn=ldaptestuser)(objectClass=user))"
2422         res = ldb.search(expression="(&(cn=ldaptestuser)(objectClass=user))")
2423         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser)(objectClass=user))")
2424
2425         self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn))
2426         self.assertEquals(str(res[0]["cn"]), "ldaptestuser")
2427         self.assertEquals(str(res[0]["name"]), "ldaptestuser")
2428         self.assertEquals(set(res[0]["objectClass"]), set(["top", "person", "organizationalPerson", "user"]))
2429         self.assertTrue("objectGUID" in res[0])
2430         self.assertTrue("whenCreated" in res[0])
2431         self.assertEquals(str(res[0]["objectCategory"]), ("CN=Person,%s" % ldb.get_schema_basedn()))
2432         self.assertEquals(int(res[0]["sAMAccountType"][0]), ATYPE_NORMAL_ACCOUNT)
2433         self.assertEquals(int(res[0]["userAccountControl"][0]), UF_NORMAL_ACCOUNT | UF_PASSWD_NOTREQD | UF_ACCOUNTDISABLE)
2434         self.assertEquals(res[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
2435         self.assertEquals(len(res[0]["memberOf"]), 1)
2436
2437         # Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=cn=person,%s))" % ldb.get_schema_basedn()
2438         res2 = ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=cn=person,%s))" % ldb.get_schema_basedn())
2439         self.assertEquals(len(res2), 1, "Could not find (&(cn=ldaptestuser)(objectCategory=cn=person,%s))" % ldb.get_schema_basedn())
2440
2441         self.assertEquals(res[0].dn, res2[0].dn)
2442
2443         # Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon))"
2444         res3 = ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=PerSon))")
2445         self.assertEquals(len(res3), 1, "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)): matched %d" % len(res3))
2446
2447         self.assertEquals(res[0].dn, res3[0].dn)
2448
2449         if gc_ldb is not None:
2450             # Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog"
2451             res3gc = gc_ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=PerSon))")
2452             self.assertEquals(len(res3gc), 1)
2453
2454             self.assertEquals(res[0].dn, res3gc[0].dn)
2455
2456         # Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon)) in with 'phantom root' control"
2457
2458         if gc_ldb is not None:
2459             res3control = gc_ldb.search(self.base_dn, expression="(&(cn=ldaptestuser)(objectCategory=PerSon))", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:2"])
2460             self.assertEquals(len(res3control), 1, "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog")
2461
2462             self.assertEquals(res[0].dn, res3control[0].dn)
2463
2464         ldb.delete(res[0].dn)
2465
2466         # Testing ldb.search for (&(cn=ldaptestcomputer)(objectClass=user))"
2467         res = ldb.search(expression="(&(cn=ldaptestcomputer)(objectClass=user))")
2468         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser)(objectClass=user))")
2469
2470         self.assertEquals(str(res[0].dn), ("CN=ldaptestcomputer,CN=Computers," + self.base_dn))
2471         self.assertEquals(str(res[0]["cn"]), "ldaptestcomputer")
2472         self.assertEquals(str(res[0]["name"]), "ldaptestcomputer")
2473         self.assertEquals(set(res[0]["objectClass"]), set(["top", "person", "organizationalPerson", "user", "computer"]))
2474         self.assertTrue("objectGUID" in res[0])
2475         self.assertTrue("whenCreated" in res[0])
2476         self.assertEquals(str(res[0]["objectCategory"]), ("CN=Computer,%s" % ldb.get_schema_basedn()))
2477         self.assertEquals(int(res[0]["primaryGroupID"][0]), 513)
2478         self.assertEquals(int(res[0]["sAMAccountType"][0]), ATYPE_NORMAL_ACCOUNT)
2479         self.assertEquals(int(res[0]["userAccountControl"][0]), UF_NORMAL_ACCOUNT | UF_PASSWD_NOTREQD | UF_ACCOUNTDISABLE)
2480         self.assertEquals(res[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
2481         self.assertEquals(len(res[0]["memberOf"]), 1)
2482
2483         # Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=cn=computer,%s))" % ldb.get_schema_basedn()
2484         res2 = ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=cn=computer,%s))" % ldb.get_schema_basedn())
2485         self.assertEquals(len(res2), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,%s))" % ldb.get_schema_basedn())
2486
2487         self.assertEquals(res[0].dn, res2[0].dn)
2488
2489         if gc_ldb is not None:
2490             # Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=cn=computer,%s)) in Global Catalog" % gc_ldb.get_schema_basedn()
2491             res2gc = gc_ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=cn=computer,%s))" % gc_ldb.get_schema_basedn())
2492             self.assertEquals(len(res2gc), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,%s)) In Global Catalog" % gc_ldb.get_schema_basedn())
2493
2494             self.assertEquals(res[0].dn, res2gc[0].dn)
2495
2496         # Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER))"
2497         res3 = ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=compuTER))")
2498         self.assertEquals(len(res3), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER))")
2499
2500         self.assertEquals(res[0].dn, res3[0].dn)
2501
2502         if gc_ldb is not None:
2503             # Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog"
2504             res3gc = gc_ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=compuTER))")
2505             self.assertEquals(len(res3gc), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog")
2506
2507             self.assertEquals(res[0].dn, res3gc[0].dn)
2508
2509         # Testing ldb.search for (&(cn=ldaptestcomp*r)(objectCategory=compuTER))"
2510         res4 = ldb.search(expression="(&(cn=ldaptestcomp*r)(objectCategory=compuTER))")
2511         self.assertEquals(len(res4), 1, "Could not find (&(cn=ldaptestcomp*r)(objectCategory=compuTER))")
2512
2513         self.assertEquals(res[0].dn, res4[0].dn)
2514
2515         # Testing ldb.search for (&(cn=ldaptestcomput*)(objectCategory=compuTER))"
2516         res5 = ldb.search(expression="(&(cn=ldaptestcomput*)(objectCategory=compuTER))")
2517         self.assertEquals(len(res5), 1, "Could not find (&(cn=ldaptestcomput*)(objectCategory=compuTER))")
2518
2519         self.assertEquals(res[0].dn, res5[0].dn)
2520
2521         # Testing ldb.search for (&(cn=*daptestcomputer)(objectCategory=compuTER))"
2522         res6 = ldb.search(expression="(&(cn=*daptestcomputer)(objectCategory=compuTER))")
2523         self.assertEquals(len(res6), 1, "Could not find (&(cn=*daptestcomputer)(objectCategory=compuTER))")
2524
2525         self.assertEquals(res[0].dn, res6[0].dn)
2526
2527         ldb.delete("<GUID=" + ldb.schema_format_value("objectGUID", res[0]["objectGUID"][0]) + ">")
2528
2529         # Testing ldb.search for (&(cn=ldaptest2computer)(objectClass=user))"
2530         res = ldb.search(expression="(&(cn=ldaptest2computer)(objectClass=user))")
2531         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptest2computer)(objectClass=user))")
2532
2533         self.assertEquals(str(res[0].dn), "CN=ldaptest2computer,CN=Computers," + self.base_dn)
2534         self.assertEquals(str(res[0]["cn"]), "ldaptest2computer")
2535         self.assertEquals(str(res[0]["name"]), "ldaptest2computer")
2536         self.assertEquals(list(res[0]["objectClass"]), ["top", "person", "organizationalPerson", "user", "computer"])
2537         self.assertTrue("objectGUID" in res[0])
2538         self.assertTrue("whenCreated" in res[0])
2539         self.assertEquals(res[0]["objectCategory"][0], "CN=Computer,%s" % ldb.get_schema_basedn())
2540         self.assertEquals(int(res[0]["sAMAccountType"][0]), ATYPE_WORKSTATION_TRUST)
2541         self.assertEquals(int(res[0]["userAccountControl"][0]), UF_WORKSTATION_TRUST_ACCOUNT)
2542
2543         ldb.delete("<SID=" + ldb.schema_format_value("objectSID", res[0]["objectSID"][0]) + ">")
2544
2545         attrs = ["cn", "name", "objectClass", "objectGUID", "objectSID", "whenCreated", "nTSecurityDescriptor", "memberOf", "allowedAttributes", "allowedAttributesEffective"]
2546         # Testing ldb.search for (&(cn=ldaptestUSer2)(objectClass=user))"
2547         res_user = ldb.search(self.base_dn, expression="(&(cn=ldaptestUSer2)(objectClass=user))", scope=SCOPE_SUBTREE, attrs=attrs)
2548         self.assertEquals(len(res_user), 1, "Could not find (&(cn=ldaptestUSer2)(objectClass=user))")
2549
2550         self.assertEquals(str(res_user[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
2551         self.assertEquals(str(res_user[0]["cn"]), "ldaptestuser2")
2552         self.assertEquals(str(res_user[0]["name"]), "ldaptestuser2")
2553         self.assertEquals(list(res_user[0]["objectClass"]), ["top", "person", "organizationalPerson", "user"])
2554         self.assertTrue("objectSid" in res_user[0])
2555         self.assertTrue("objectGUID" in res_user[0])
2556         self.assertTrue("whenCreated" in res_user[0])
2557         self.assertTrue("nTSecurityDescriptor" in res_user[0])
2558         self.assertTrue("allowedAttributes" in res_user[0])
2559         self.assertTrue("allowedAttributesEffective" in res_user[0])
2560         self.assertEquals(res_user[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
2561
2562         ldaptestuser2_sid = res_user[0]["objectSid"][0]
2563         ldaptestuser2_guid = res_user[0]["objectGUID"][0]
2564
2565         attrs = ["cn", "name", "objectClass", "objectGUID", "objectSID", "whenCreated", "nTSecurityDescriptor", "member", "allowedAttributes", "allowedAttributesEffective"]
2566         # Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group))"
2567         res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs)
2568         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))")
2569
2570         self.assertEquals(str(res[0].dn), ("CN=ldaptestgroup2,CN=Users," + self.base_dn))
2571         self.assertEquals(str(res[0]["cn"]), "ldaptestgroup2")
2572         self.assertEquals(str(res[0]["name"]), "ldaptestgroup2")
2573         self.assertEquals(list(res[0]["objectClass"]), ["top", "group"])
2574         self.assertTrue("objectGUID" in res[0])
2575         self.assertTrue("objectSid" in res[0])
2576         self.assertTrue("whenCreated" in res[0])
2577         self.assertTrue("nTSecurityDescriptor" in res[0])
2578         self.assertTrue("allowedAttributes" in res[0])
2579         self.assertTrue("allowedAttributesEffective" in res[0])
2580         memberUP = []
2581         for m in res[0]["member"]:
2582             memberUP.append(m.upper())
2583         self.assertTrue(("CN=ldaptestuser2,CN=Users," + self.base_dn).upper() in memberUP)
2584
2585         res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs, controls=["extended_dn:1:1"])
2586         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))")
2587
2588         print(res[0]["member"])
2589         memberUP = []
2590         for m in res[0]["member"]:
2591             memberUP.append(m.upper())
2592         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())
2593
2594         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)
2595
2596         # Quicktest for linked attributes"
2597         ldb.modify_ldif("""
2598 dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
2599 changetype: modify
2600 replace: member
2601 member: CN=ldaptestuser2,CN=Users,""" + self.base_dn + """
2602 member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
2603 """)
2604
2605         ldb.modify_ldif("""
2606 dn: <GUID=""" + ldb.schema_format_value("objectGUID", res[0]["objectGUID"][0]) + """>
2607 changetype: modify
2608 replace: member
2609 member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
2610 """)
2611
2612         ldb.modify_ldif("""
2613 dn: <SID=""" + ldb.schema_format_value("objectSid", res[0]["objectSid"][0]) + """>
2614 changetype: modify
2615 delete: member
2616 """)
2617
2618         ldb.modify_ldif("""
2619 dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
2620 changetype: modify
2621 add: member
2622 member: <GUID=""" + ldb.schema_format_value("objectGUID", res[0]["objectGUID"][0]) + """>
2623 member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
2624 """)
2625
2626         ldb.modify_ldif("""
2627 dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
2628 changetype: modify
2629 replace: member
2630 """)
2631
2632         ldb.modify_ldif("""
2633 dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
2634 changetype: modify
2635 add: member
2636 member: <SID=""" + ldb.schema_format_value("objectSid", res_user[0]["objectSid"][0]) + """>
2637 member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
2638 """)
2639
2640         ldb.modify_ldif("""
2641 dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
2642 changetype: modify
2643 delete: member
2644 member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
2645 """)
2646
2647         res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs)
2648         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))")
2649
2650         self.assertEquals(str(res[0].dn), ("CN=ldaptestgroup2,CN=Users," + self.base_dn))
2651         self.assertEquals(res[0]["member"][0], ("CN=ldaptestuser2,CN=Users," + self.base_dn))
2652         self.assertEquals(len(res[0]["member"]), 1)
2653
2654         ldb.delete(("CN=ldaptestuser2,CN=Users," + self.base_dn))
2655
2656         time.sleep(4)
2657
2658         attrs = ["cn", "name", "objectClass", "objectGUID", "whenCreated", "nTSecurityDescriptor", "member"]
2659         # Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete"
2660         res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs)
2661         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete")
2662
2663         self.assertEquals(str(res[0].dn), ("CN=ldaptestgroup2,CN=Users," + self.base_dn))
2664         self.assertTrue("member" not in res[0])
2665
2666         # Testing ldb.search for (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))"
2667         res = ldb.search(expression="(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
2668         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
2669         res = ldb.search(expression="(&(cn=ldaptestutf8user èùéìòà)(objectclass=user))")
2670         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
2671
2672         self.assertEquals(str(res[0].dn), ("CN=ldaptestutf8user èùéìòà,CN=Users," + self.base_dn))
2673         self.assertEquals(str(res[0]["cn"]), "ldaptestutf8user èùéìòà")
2674         self.assertEquals(str(res[0]["name"]), "ldaptestutf8user èùéìòà")
2675         self.assertEquals(list(res[0]["objectClass"]), ["top", "person", "organizationalPerson", "user"])
2676         self.assertTrue("objectGUID" in res[0])
2677         self.assertTrue("whenCreated" in res[0])
2678
2679         # delete "ldaptestutf8user"
2680         ldb.delete(res[0].dn)
2681
2682         # Testing ldb.search for (&(cn=ldaptestutf8user2*)(objectClass=user))"
2683         res = ldb.search(expression="(&(cn=ldaptestutf8user2*)(objectClass=user))")
2684         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestutf8user2*)(objectClass=user))")
2685
2686         # Testing ldb.search for (&(cn=ldaptestutf8user2  ÈÙÉÌÒÀ)(objectClass=user))"
2687         res = ldb.search(expression="(&(cn=ldaptestutf8user2  ÈÙÉÌÒÀ)(objectClass=user))")
2688         self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestutf8user2  ÈÙÉÌÒÀ)(objectClass=user))")
2689
2690         # delete "ldaptestutf8user2 "
2691         ldb.delete(res[0].dn)
2692
2693         ldb.delete(("CN=ldaptestgroup2,CN=Users," + self.base_dn))
2694
2695         # Testing that we can't get at the configuration DN from the main search base"
2696         res = ldb.search(self.base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"])
2697         self.assertEquals(len(res), 0)
2698
2699         # 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"
2700         res = ldb.search(self.base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:2"])
2701         self.assertTrue(len(res) > 0)
2702
2703         if gc_ldb is not None:
2704             # Testing that we can get at the configuration DN from the main search base on the GC port with the search_options control == 0"
2705
2706             res = gc_ldb.search(self.base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:0"])
2707             self.assertTrue(len(res) > 0)
2708
2709             # Testing that we do find configuration elements in the global catlog"
2710             res = gc_ldb.search(self.base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"])
2711             self.assertTrue(len(res) > 0)
2712
2713             # Testing that we do find configuration elements and user elements at the same time"
2714             res = gc_ldb.search(self.base_dn, expression="(|(objectClass=crossRef)(objectClass=person))", scope=SCOPE_SUBTREE, attrs=["cn"])
2715             self.assertTrue(len(res) > 0)
2716
2717             # Testing that we do find configuration elements in the global catlog, with the configuration basedn"
2718             res = gc_ldb.search(self.configuration_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"])
2719             self.assertTrue(len(res) > 0)
2720
2721         # Testing that we can get at the configuration DN on the main LDAP port"
2722         res = ldb.search(self.configuration_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"])
2723         self.assertTrue(len(res) > 0)
2724
2725         # Testing objectCategory canonacolisation"
2726         res = ldb.search(self.configuration_dn, expression="objectCategory=ntDsDSA", scope=SCOPE_SUBTREE, attrs=["cn"])
2727         self.assertTrue(len(res) > 0, "Didn't find any records with objectCategory=ntDsDSA")
2728         self.assertTrue(len(res) != 0)
2729
2730         res = ldb.search(self.configuration_dn, expression="objectCategory=CN=ntDs-DSA," + self.schema_dn, scope=SCOPE_SUBTREE, attrs=["cn"])
2731         self.assertTrue(len(res) > 0, "Didn't find any records with objectCategory=CN=ntDs-DSA," + self.schema_dn)
2732         self.assertTrue(len(res) != 0)
2733
2734         # Testing objectClass attribute order on "+ self.base_dn
2735         res = ldb.search(expression="objectClass=domain", base=self.base_dn,
2736                          scope=SCOPE_BASE, attrs=["objectClass"])
2737         self.assertEquals(len(res), 1)
2738
2739         self.assertEquals(list(res[0]["objectClass"]), ["top", "domain", "domainDNS"])
2740
2741     #  check enumeration
2742
2743         # Testing ldb.search for objectCategory=person"
2744         res = ldb.search(self.base_dn, expression="objectCategory=person", scope=SCOPE_SUBTREE, attrs=["cn"])
2745         self.assertTrue(len(res) > 0)
2746
2747         # Testing ldb.search for objectCategory=person with domain scope control"
2748         res = ldb.search(self.base_dn, expression="objectCategory=person", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"])
2749         self.assertTrue(len(res) > 0)
2750
2751         # Testing ldb.search for objectCategory=user"
2752         res = ldb.search(self.base_dn, expression="objectCategory=user", scope=SCOPE_SUBTREE, attrs=["cn"])
2753         self.assertTrue(len(res) > 0)
2754
2755         # Testing ldb.search for objectCategory=user with domain scope control"
2756         res = ldb.search(self.base_dn, expression="objectCategory=user", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"])
2757         self.assertTrue(len(res) > 0)
2758
2759         # Testing ldb.search for objectCategory=group"
2760         res = ldb.search(self.base_dn, expression="objectCategory=group", scope=SCOPE_SUBTREE, attrs=["cn"])
2761         self.assertTrue(len(res) > 0)
2762
2763         # Testing ldb.search for objectCategory=group with domain scope control"
2764         res = ldb.search(self.base_dn, expression="objectCategory=group", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"])
2765         self.assertTrue(len(res) > 0)
2766
2767         # Testing creating a user with the posixAccount objectClass"
2768         self.ldb.add_ldif("""dn: cn=posixuser,CN=Users,%s
2769 objectClass: top
2770 objectClass: person
2771 objectClass: posixAccount
2772 objectClass: user
2773 objectClass: organizationalPerson
2774 cn: posixuser
2775 uid: posixuser
2776 sn: posixuser
2777 uidNumber: 10126
2778 gidNumber: 10126
2779 homeDirectory: /home/posixuser
2780 loginShell: /bin/bash
2781 gecos: Posix User;;;
2782 description: A POSIX user"""% (self.base_dn))
2783
2784         # Testing removing the posixAccount objectClass from an existing user"
2785         self.ldb.modify_ldif("""dn: cn=posixuser,CN=Users,%s
2786 changetype: modify
2787 delete: objectClass
2788 objectClass: posixAccount"""% (self.base_dn))
2789
2790         # Testing adding the posixAccount objectClass to an existing user"
2791         self.ldb.modify_ldif("""dn: cn=posixuser,CN=Users,%s
2792 changetype: modify
2793 add: objectClass
2794 objectClass: posixAccount"""% (self.base_dn))
2795
2796         delete_force(self.ldb, "cn=posixuser,cn=users," + self.base_dn)
2797         delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
2798         delete_force(self.ldb, "cn=ldaptestuser2,cn=users," + self.base_dn)
2799         delete_force(self.ldb, "cn=ldaptestuser3,cn=users," + self.base_dn)
2800         delete_force(self.ldb, "cn=ldaptestuser4,cn=ldaptestcontainer," + self.base_dn)
2801         delete_force(self.ldb, "cn=ldaptestuser4,cn=ldaptestcontainer2," + self.base_dn)
2802         delete_force(self.ldb, "cn=ldaptestuser5,cn=users," + self.base_dn)
2803         delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
2804         delete_force(self.ldb, "cn=ldaptestgroup2,cn=users," + self.base_dn)
2805         delete_force(self.ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
2806         delete_force(self.ldb, "cn=ldaptest2computer,cn=computers," + self.base_dn)
2807         delete_force(self.ldb, "cn=ldaptestcomputer3,cn=computers," + self.base_dn)
2808         delete_force(self.ldb, "cn=ldaptestutf8user èùéìòà,cn=users," + self.base_dn)
2809         delete_force(self.ldb, "cn=ldaptestutf8user2  èùéìòà,cn=users," + self.base_dn)
2810         delete_force(self.ldb, "cn=ldaptestcontainer," + self.base_dn)
2811         delete_force(self.ldb, "cn=ldaptestcontainer2," + self.base_dn)
2812
2813     def test_security_descriptor_add(self):
2814         """ Testing ldb.add_ldif() for nTSecurityDescriptor """
2815         user_name = "testdescriptoruser1"
2816         user_dn = "CN=%s,CN=Users,%s" % (user_name, self.base_dn)
2817         #
2818         # Test an empty security descriptor (naturally this shouldn't work)
2819         #
2820         delete_force(self.ldb, user_dn)
2821         try:
2822             self.ldb.add({ "dn": user_dn,
2823                            "objectClass": "user",
2824                            "sAMAccountName": user_name,
2825                            "nTSecurityDescriptor": [] })
2826             self.fail()
2827         except LdbError as e107:
2828             (num, _) = e107.args
2829             self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
2830         finally:
2831             delete_force(self.ldb, user_dn)
2832         #
2833         # Test add_ldif() with SDDL security descriptor input
2834         #
2835         try:
2836             sddl = "O:DUG:DUD:PAI(A;;RPWP;;;AU)S:PAI"
2837             self.ldb.add_ldif("""
2838 dn: """ + user_dn + """
2839 objectclass: user
2840 sAMAccountName: """ + user_name + """
2841 nTSecurityDescriptor: """ + sddl)
2842             res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2843             desc = res[0]["nTSecurityDescriptor"][0]
2844             desc = ndr_unpack( security.descriptor, desc )
2845             desc_sddl = desc.as_sddl( self.domain_sid )
2846             self.assertEqual(desc_sddl, sddl)
2847         finally:
2848             delete_force(self.ldb, user_dn)
2849         #
2850         # Test add_ldif() with BASE64 security descriptor
2851         #
2852         try:
2853             sddl = "O:DUG:DUD:PAI(A;;RPWP;;;AU)S:PAI"
2854             desc = security.descriptor.from_sddl(sddl, self.domain_sid)
2855             desc_binary = ndr_pack(desc)
2856             desc_base64 = base64.b64encode(desc_binary)
2857             self.ldb.add_ldif("""
2858 dn: """ + user_dn + """
2859 objectclass: user
2860 sAMAccountName: """ + user_name + """
2861 nTSecurityDescriptor:: """ + desc_base64)
2862             res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2863             desc = res[0]["nTSecurityDescriptor"][0]
2864             desc = ndr_unpack(security.descriptor, desc)
2865             desc_sddl = desc.as_sddl(self.domain_sid)
2866             self.assertEqual(desc_sddl, sddl)
2867         finally:
2868             delete_force(self.ldb, user_dn)
2869
2870     def test_security_descriptor_add_neg(self):
2871         """Test add_ldif() with BASE64 security descriptor input using WRONG domain SID
2872             Negative test
2873         """
2874         user_name = "testdescriptoruser1"
2875         user_dn = "CN=%s,CN=Users,%s" % (user_name, self.base_dn)
2876         delete_force(self.ldb, user_dn)
2877         try:
2878             sddl = "O:DUG:DUD:AI(A;;RPWP;;;AU)S:PAI"
2879             desc = security.descriptor.from_sddl(sddl, security.dom_sid('S-1-5-21'))
2880             desc_base64 = base64.b64encode( ndr_pack(desc) )
2881             self.ldb.add_ldif("""
2882 dn: """ + user_dn + """
2883 objectclass: user
2884 sAMAccountName: """ + user_name + """
2885 nTSecurityDescriptor:: """ + desc_base64)
2886             res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2887             self.assertTrue("nTSecurityDescriptor" in res[0])
2888             desc = res[0]["nTSecurityDescriptor"][0]
2889             desc = ndr_unpack(security.descriptor, desc)
2890             desc_sddl = desc.as_sddl(self.domain_sid)
2891             self.assertTrue("O:S-1-5-21-513G:S-1-5-21-513D:AI(A;;RPWP;;;AU)" in desc_sddl)
2892         finally:
2893             delete_force(self.ldb, user_dn)
2894
2895     def test_security_descriptor_modify(self):
2896         """ Testing ldb.modify_ldif() for nTSecurityDescriptor """
2897         user_name = "testdescriptoruser2"
2898         user_dn = "CN=%s,CN=Users,%s" % (user_name, self.base_dn)
2899         #
2900         # Test an empty security descriptor (naturally this shouldn't work)
2901         #
2902         delete_force(self.ldb, user_dn)
2903         self.ldb.add({ "dn": user_dn,
2904                        "objectClass": "user",
2905                        "sAMAccountName": user_name })
2906
2907         m = Message()
2908         m.dn = Dn(ldb, user_dn)
2909         m["nTSecurityDescriptor"] = MessageElement([], FLAG_MOD_ADD,
2910                                                    "nTSecurityDescriptor")
2911         try:
2912             self.ldb.modify(m)
2913             self.fail()
2914         except LdbError as e108:
2915             (num, _) = e108.args
2916             self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
2917
2918         m = Message()
2919         m.dn = Dn(ldb, user_dn)
2920         m["nTSecurityDescriptor"] = MessageElement([], FLAG_MOD_REPLACE,
2921                                                    "nTSecurityDescriptor")
2922         try:
2923             self.ldb.modify(m)
2924             self.fail()
2925         except LdbError as e109:
2926             (num, _) = e109.args
2927             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
2928
2929         m = Message()
2930         m.dn = Dn(ldb, user_dn)
2931         m["nTSecurityDescriptor"] = MessageElement([], FLAG_MOD_DELETE,
2932                                                    "nTSecurityDescriptor")
2933         try:
2934             self.ldb.modify(m)
2935             self.fail()
2936         except LdbError as e110:
2937             (num, _) = e110.args
2938             self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
2939
2940         delete_force(self.ldb, user_dn)
2941         #
2942         # Test modify_ldif() with SDDL security descriptor input
2943         # Add ACE to the original descriptor test
2944         #
2945         try:
2946             self.ldb.add_ldif("""
2947 dn: """ + user_dn + """
2948 objectclass: user
2949 sAMAccountName: """ + user_name)
2950             # Modify descriptor
2951             res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2952             desc = res[0]["nTSecurityDescriptor"][0]
2953             desc = ndr_unpack(security.descriptor, desc)
2954             desc_sddl = desc.as_sddl(self.domain_sid)
2955             sddl = desc_sddl[:desc_sddl.find("(")] + "(A;;RPWP;;;AU)" + desc_sddl[desc_sddl.find("("):]
2956             mod = """
2957 dn: """ + user_dn + """
2958 changetype: modify
2959 replace: nTSecurityDescriptor
2960 nTSecurityDescriptor: """ + sddl
2961             self.ldb.modify_ldif(mod)
2962             # Read modified descriptor
2963             res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2964             desc = res[0]["nTSecurityDescriptor"][0]
2965             desc = ndr_unpack(security.descriptor, desc)
2966             desc_sddl = desc.as_sddl(self.domain_sid)
2967             self.assertEqual(desc_sddl, sddl)
2968         finally:
2969             delete_force(self.ldb, user_dn)
2970         #
2971         # Test modify_ldif() with SDDL security descriptor input
2972         # New desctiptor test
2973         #
2974         try:
2975             self.ldb.add_ldif("""
2976 dn: """ + user_dn + """
2977 objectclass: user
2978 sAMAccountName: """ + user_name)
2979             # Modify descriptor
2980             sddl = "O:DUG:DUD:PAI(A;;RPWP;;;AU)S:PAI"
2981             mod = """
2982 dn: """ + user_dn + """
2983 changetype: modify
2984 replace: nTSecurityDescriptor
2985 nTSecurityDescriptor: """ + sddl
2986             self.ldb.modify_ldif(mod)
2987             # Read modified descriptor
2988             res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2989             desc = res[0]["nTSecurityDescriptor"][0]
2990             desc = ndr_unpack(security.descriptor, desc)
2991             desc_sddl = desc.as_sddl(self.domain_sid)
2992             self.assertEqual(desc_sddl, sddl)
2993         finally:
2994             delete_force(self.ldb, user_dn)
2995         #
2996         # Test modify_ldif() with BASE64 security descriptor input
2997         # Add ACE to the original descriptor test
2998         #
2999         try:
3000             self.ldb.add_ldif("""
3001 dn: """ + user_dn + """
3002 objectclass: user
3003 sAMAccountName: """ + user_name)
3004             # Modify descriptor
3005             res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
3006             desc = res[0]["nTSecurityDescriptor"][0]
3007             desc = ndr_unpack(security.descriptor, desc)
3008             desc_sddl = desc.as_sddl(self.domain_sid)
3009             sddl = desc_sddl[:desc_sddl.find("(")] + "(A;;RPWP;;;AU)" + desc_sddl[desc_sddl.find("("):]
3010             desc = security.descriptor.from_sddl(sddl, self.domain_sid)
3011             desc_base64 = base64.b64encode(ndr_pack(desc))
3012             mod = """
3013 dn: """ + user_dn + """
3014 changetype: modify
3015 replace: nTSecurityDescriptor
3016 nTSecurityDescriptor:: """ + desc_base64
3017             self.ldb.modify_ldif(mod)
3018             # Read modified descriptor
3019             res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
3020             desc = res[0]["nTSecurityDescriptor"][0]
3021             desc = ndr_unpack(security.descriptor, desc)
3022             desc_sddl = desc.as_sddl(self.domain_sid)
3023             self.assertEqual(desc_sddl, sddl)
3024         finally:
3025             delete_force(self.ldb, user_dn)
3026         #
3027         # Test modify_ldif() with BASE64 security descriptor input
3028         # New descriptor test
3029         #
3030         try:
3031             delete_force(self.ldb, user_dn)
3032             self.ldb.add_ldif("""
3033 dn: """ + user_dn + """
3034 objectclass: user
3035 sAMAccountName: """ + user_name)
3036             # Modify descriptor
3037             sddl = "O:DUG:DUD:PAI(A;;RPWP;;;AU)S:PAI"
3038             desc = security.descriptor.from_sddl(sddl, self.domain_sid)
3039             desc_base64 = base64.b64encode(ndr_pack(desc))
3040             mod = """
3041 dn: """ + user_dn + """
3042 changetype: modify
3043 replace: nTSecurityDescriptor
3044 nTSecurityDescriptor:: """ + desc_base64
3045             self.ldb.modify_ldif(mod)
3046             # Read modified descriptor
3047             res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
3048             desc = res[0]["nTSecurityDescriptor"][0]
3049             desc = ndr_unpack(security.descriptor, desc)
3050             desc_sddl = desc.as_sddl(self.domain_sid)
3051             self.assertEqual(desc_sddl, sddl)
3052         finally:
3053             delete_force(self.ldb, user_dn)
3054
3055     def test_dsheuristics(self):
3056         """Tests the 'dSHeuristics' attribute"""
3057         # Tests the 'dSHeuristics' attribute"
3058
3059         # Get the current value to restore it later
3060         dsheuristics = self.ldb.get_dsheuristics()
3061         # Perform the length checks: for each decade (except the 0th) we need
3062         # the first index to be the number. This goes till the 9th one, beyond
3063         # there does not seem to be another limitation.
3064         try:
3065             dshstr = ""
3066             for i in range(1,11):
3067                 # This is in the range
3068                 self.ldb.set_dsheuristics(dshstr + "x")
3069                 self.ldb.set_dsheuristics(dshstr + "xxxxx")
3070                 dshstr = dshstr + "xxxxxxxxx"
3071                 if i < 10:
3072                     # Not anymore in the range, new decade specifier needed
3073                     try:
3074                         self.ldb.set_dsheuristics(dshstr + "x")
3075                         self.fail()
3076                     except LdbError as e:
3077                         (num, _) = e.args
3078                         self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
3079                     dshstr = dshstr + str(i)
3080                 else:
3081                     # There does not seem to be an upper limit
3082                     self.ldb.set_dsheuristics(dshstr + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
3083             # apart from the above, all char values are accepted
3084             self.ldb.set_dsheuristics("123ABC-+!1asdfg@#^")
3085             self.assertEquals(self.ldb.get_dsheuristics(), "123ABC-+!1asdfg@#^")
3086         finally:
3087             # restore old value
3088             self.ldb.set_dsheuristics(dsheuristics)
3089
3090     def test_ldapControlReturn(self):
3091         """Testing that if we request a control that return a control it
3092            really return something"""
3093         res = self.ldb.search(attrs=["cn"],
3094                               controls=["paged_results:1:10"])
3095         self.assertEquals(len(res.controls), 1)
3096         self.assertEquals(res.controls[0].oid, "1.2.840.113556.1.4.319")
3097         s = str(res.controls[0])
3098
3099     def test_operational(self):
3100         """Tests operational attributes"""
3101         # Tests operational attributes"
3102
3103         res = self.ldb.search(self.base_dn, scope=SCOPE_BASE,
3104                               attrs=["createTimeStamp", "modifyTimeStamp",
3105                                      "structuralObjectClass", "whenCreated",
3106                                      "whenChanged"])
3107         self.assertEquals(len(res), 1)
3108         self.assertTrue("createTimeStamp" in res[0])
3109         self.assertTrue("modifyTimeStamp" in res[0])
3110         self.assertTrue("structuralObjectClass" in res[0])
3111         self.assertTrue("whenCreated" in res[0])
3112         self.assertTrue("whenChanged" in res[0])
3113
3114     def test_timevalues1(self):
3115         """Tests possible syntax of time attributes"""
3116
3117         user_name = "testtimevaluesuser1"
3118         user_dn = "CN=%s,CN=Users,%s" % (user_name, self.base_dn)
3119
3120         delete_force(self.ldb, user_dn)
3121         self.ldb.add({ "dn": user_dn,
3122                        "objectClass": "user",
3123                        "sAMAccountName": user_name })
3124
3125         #
3126         # We check the following values:
3127         #
3128         #   370101000000Z     => 20370101000000.0Z
3129         # 20370102000000.*Z   => 20370102000000.0Z
3130         #
3131         ext = [ "Z", ".0Z", ".Z", ".000Z", ".RandomIgnoredCharacters...987654321Z" ]
3132         for i in range(0, len(ext)):
3133             v_raw = "203701%02d000000" % (i + 1)
3134             if ext[i] == "Z":
3135                 v_set = v_raw[2:] + ext[i]
3136             else:
3137                 v_set = v_raw + ext[i]
3138             v_get = v_raw + ".0Z"
3139
3140             m = Message()
3141             m.dn = Dn(ldb, user_dn)
3142             m["msTSExpireDate"] = MessageElement([v_set],
3143                                                  FLAG_MOD_REPLACE,
3144                                                  "msTSExpireDate")
3145             self.ldb.modify(m)
3146
3147             res = self.ldb.search(base=user_dn, scope=SCOPE_BASE, attrs=["msTSExpireDate"])
3148             self.assertTrue(len(res) == 1)
3149             self.assertTrue("msTSExpireDate" in res[0])
3150             self.assertTrue(len(res[0]["msTSExpireDate"]) == 1)
3151             self.assertEquals(res[0]["msTSExpireDate"][0], v_get)
3152
3153 class BaseDnTests(samba.tests.TestCase):
3154
3155     def setUp(self):
3156         super(BaseDnTests, self).setUp()
3157         self.ldb = ldb
3158
3159     def test_rootdse_attrs(self):
3160         """Testing for all rootDSE attributes"""
3161         res = self.ldb.search("", scope=SCOPE_BASE, attrs=[])
3162         self.assertEquals(len(res), 1)
3163
3164     def test_highestcommittedusn(self):
3165         """Testing for highestCommittedUSN"""
3166         res = self.ldb.search("", scope=SCOPE_BASE, attrs=["highestCommittedUSN"])
3167         self.assertEquals(len(res), 1)
3168         self.assertTrue(int(res[0]["highestCommittedUSN"][0]) != 0)
3169
3170     def test_netlogon(self):
3171         """Testing for netlogon via LDAP"""
3172         res = self.ldb.search("", scope=SCOPE_BASE, attrs=["netlogon"])
3173         self.assertEquals(len(res), 0)
3174
3175     def test_netlogon_highestcommitted_usn(self):
3176         """Testing for netlogon and highestCommittedUSN via LDAP"""
3177         res = self.ldb.search("", scope=SCOPE_BASE,
3178                 attrs=["netlogon", "highestCommittedUSN"])
3179         self.assertEquals(len(res), 0)
3180
3181     def test_namingContexts(self):
3182         """Testing for namingContexts in rootDSE"""
3183         res = self.ldb.search("", scope=SCOPE_BASE,
3184                 attrs=["namingContexts", "defaultNamingContext", "schemaNamingContext", "configurationNamingContext"])
3185         self.assertEquals(len(res), 1)
3186
3187         ncs = set([])
3188         for nc in res[0]["namingContexts"]:
3189             self.assertTrue(nc not in ncs)
3190             ncs.add(nc)
3191
3192         self.assertTrue(res[0]["defaultNamingContext"][0] in ncs)
3193         self.assertTrue(res[0]["configurationNamingContext"][0] in ncs)
3194         self.assertTrue(res[0]["schemaNamingContext"][0] in ncs)
3195
3196     def test_serverPath(self):
3197         """Testing the server paths in rootDSE"""
3198         res = self.ldb.search("", scope=SCOPE_BASE,
3199                               attrs=["dsServiceName", "serverName"])
3200         self.assertEquals(len(res), 1)
3201
3202         self.assertTrue("CN=Servers" in res[0]["dsServiceName"][0])
3203         self.assertTrue("CN=Sites" in res[0]["dsServiceName"][0])
3204         self.assertTrue("CN=NTDS Settings" in res[0]["dsServiceName"][0])
3205         self.assertTrue("CN=Servers" in res[0]["serverName"][0])
3206         self.assertTrue("CN=Sites" in res[0]["serverName"][0])
3207         self.assertFalse("CN=NTDS Settings" in res[0]["serverName"][0])
3208
3209     def test_functionality(self):
3210         """Testing the server paths in rootDSE"""
3211         res = self.ldb.search("", scope=SCOPE_BASE,
3212                               attrs=["forestFunctionality", "domainFunctionality", "domainControllerFunctionality"])
3213         self.assertEquals(len(res), 1)
3214         self.assertEquals(len(res[0]["forestFunctionality"]), 1)
3215         self.assertEquals(len(res[0]["domainFunctionality"]), 1)
3216         self.assertEquals(len(res[0]["domainControllerFunctionality"]), 1)
3217
3218         self.assertTrue(int(res[0]["forestFunctionality"][0]) <= int(res[0]["domainFunctionality"][0]))
3219         self.assertTrue(int(res[0]["domainControllerFunctionality"][0]) >= int(res[0]["domainFunctionality"][0]))
3220
3221         res2 = self.ldb.search("", scope=SCOPE_BASE,
3222                               attrs=["dsServiceName", "serverName"])
3223         self.assertEquals(len(res2), 1)
3224         self.assertEquals(len(res2[0]["dsServiceName"]), 1)
3225
3226         res3 = self.ldb.search(res2[0]["dsServiceName"][0], scope=SCOPE_BASE, attrs=["msDS-Behavior-Version"])
3227         self.assertEquals(len(res3), 1)
3228         self.assertEquals(len(res3[0]["msDS-Behavior-Version"]), 1)
3229         self.assertEquals(int(res[0]["domainControllerFunctionality"][0]), int(res3[0]["msDS-Behavior-Version"][0]))
3230
3231         res4 = self.ldb.search(ldb.domain_dn(), scope=SCOPE_BASE, attrs=["msDS-Behavior-Version"])
3232         self.assertEquals(len(res4), 1)
3233         self.assertEquals(len(res4[0]["msDS-Behavior-Version"]), 1)
3234         self.assertEquals(int(res[0]["domainFunctionality"][0]), int(res4[0]["msDS-Behavior-Version"][0]))
3235
3236         res5 = self.ldb.search("cn=partitions,%s" % ldb.get_config_basedn(), scope=SCOPE_BASE, attrs=["msDS-Behavior-Version"])
3237         self.assertEquals(len(res5), 1)
3238         self.assertEquals(len(res5[0]["msDS-Behavior-Version"]), 1)
3239         self.assertEquals(int(res[0]["forestFunctionality"][0]), int(res5[0]["msDS-Behavior-Version"][0]))
3240
3241     def test_dnsHostname(self):
3242         """Testing the DNS hostname in rootDSE"""
3243         res = self.ldb.search("", scope=SCOPE_BASE,
3244                               attrs=["dnsHostName", "serverName"])
3245         self.assertEquals(len(res), 1)
3246
3247         res2 = self.ldb.search(res[0]["serverName"][0], scope=SCOPE_BASE,
3248                                attrs=["dNSHostName"])
3249         self.assertEquals(len(res2), 1)
3250
3251         self.assertEquals(res[0]["dnsHostName"][0], res2[0]["dNSHostName"][0])
3252
3253     def test_ldapServiceName(self):
3254         """Testing the ldap service name in rootDSE"""
3255         res = self.ldb.search("", scope=SCOPE_BASE,
3256                               attrs=["ldapServiceName", "dnsHostName"])
3257         self.assertEquals(len(res), 1)
3258         self.assertTrue("ldapServiceName" in res[0])
3259         self.assertTrue("dnsHostName" in res[0])
3260
3261         (hostname, _, dns_domainname) = res[0]["dnsHostName"][0].partition(".")
3262
3263         given = res[0]["ldapServiceName"][0]
3264         expected = "%s:%s$@%s" % (dns_domainname.lower(), hostname.lower(), dns_domainname.upper())
3265         self.assertEquals(given, expected)
3266
3267 if not "://" in host:
3268     if os.path.isfile(host):
3269         host = "tdb://%s" % host
3270     else:
3271         host = "ldap://%s" % host
3272
3273 ldb = SamDB(host, credentials=creds, session_info=system_session(lp), lp=lp)
3274 if not "tdb://" in host:
3275     gc_ldb = Ldb("%s:3268" % host, credentials=creds,
3276                  session_info=system_session(lp), lp=lp)
3277 else:
3278     gc_ldb = None
3279
3280 TestProgram(module=__name__, opts=subunitopts)