2 # -*- coding: utf-8 -*-
3 # This is a port of the original in testprogs/ejs/ldap.js
11 sys.path.append("bin/python")
13 samba.ensure_external_module("testtools", "testtools")
14 samba.ensure_external_module("subunit", "subunit/python")
16 import samba.getopt as options
18 from samba.auth import system_session
19 from ldb import SCOPE_SUBTREE, SCOPE_ONELEVEL, SCOPE_BASE, LdbError
20 from ldb import ERR_NO_SUCH_OBJECT, ERR_ATTRIBUTE_OR_VALUE_EXISTS
21 from ldb import ERR_ENTRY_ALREADY_EXISTS, ERR_UNWILLING_TO_PERFORM
22 from ldb import ERR_NOT_ALLOWED_ON_NON_LEAF, ERR_OTHER, ERR_INVALID_DN_SYNTAX
23 from ldb import ERR_NO_SUCH_ATTRIBUTE, ERR_INVALID_ATTRIBUTE_SYNTAX
24 from ldb import ERR_OBJECT_CLASS_VIOLATION, ERR_NOT_ALLOWED_ON_RDN
25 from ldb import ERR_NAMING_VIOLATION, ERR_CONSTRAINT_VIOLATION
26 from ldb import Message, MessageElement, Dn
27 from ldb import FLAG_MOD_ADD, FLAG_MOD_REPLACE, FLAG_MOD_DELETE
28 from ldb import timestring
30 from samba.samdb import SamDB
31 from samba.dsdb import (UF_NORMAL_ACCOUNT,
32 UF_WORKSTATION_TRUST_ACCOUNT,
33 UF_PASSWD_NOTREQD, UF_ACCOUNTDISABLE, ATYPE_NORMAL_ACCOUNT,
34 ATYPE_WORKSTATION_TRUST, SYSTEM_FLAG_DOMAIN_DISALLOW_MOVE,
35 SYSTEM_FLAG_CONFIG_ALLOW_RENAME, SYSTEM_FLAG_CONFIG_ALLOW_MOVE,
36 SYSTEM_FLAG_CONFIG_ALLOW_LIMITED_MOVE)
38 from subunit.run import SubunitTestRunner
41 from samba.ndr import ndr_pack, ndr_unpack
42 from samba.dcerpc import security
43 from samba.tests import delete_force
45 parser = optparse.OptionParser("ldap.py [options] <host>")
46 sambaopts = options.SambaOptions(parser)
47 parser.add_option_group(sambaopts)
48 parser.add_option_group(options.VersionOptions(parser))
49 # use command line creds if available
50 credopts = options.CredentialsOptions(parser)
51 parser.add_option_group(credopts)
52 opts, args = parser.parse_args()
60 lp = sambaopts.get_loadparm()
61 creds = credopts.get_credentials(lp)
63 class BasicTests(unittest.TestCase):
66 super(BasicTests, self).setUp()
69 self.base_dn = ldb.domain_dn()
70 self.configuration_dn = ldb.get_config_basedn().get_linearized()
71 self.schema_dn = ldb.get_schema_basedn().get_linearized()
72 self.domain_sid = security.dom_sid(ldb.get_domain_sid())
74 print "baseDN: %s\n" % self.base_dn
76 delete_force(self.ldb, "cn=posixuser,cn=users," + self.base_dn)
77 delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
78 delete_force(self.ldb, "cn=ldaptestuser2,cn=users," + self.base_dn)
79 delete_force(self.ldb, "cn=ldaptestuser3,cn=users," + self.base_dn)
80 delete_force(self.ldb, "cn=ldaptestuser4,cn=ldaptestcontainer," + self.base_dn)
81 delete_force(self.ldb, "cn=ldaptestuser4,cn=ldaptestcontainer2," + self.base_dn)
82 delete_force(self.ldb, "cn=ldaptestuser5,cn=users," + self.base_dn)
83 delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
84 delete_force(self.ldb, "cn=ldaptestgroup2,cn=users," + self.base_dn)
85 delete_force(self.ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
86 delete_force(self.ldb, "cn=ldaptest2computer,cn=computers," + self.base_dn)
87 delete_force(self.ldb, "cn=ldaptestcomputer3,cn=computers," + self.base_dn)
88 delete_force(self.ldb, "cn=ldaptestutf8user èùéìòà,cn=users," + self.base_dn)
89 delete_force(self.ldb, "cn=ldaptestutf8user2 èùéìòà,cn=users," + self.base_dn)
90 delete_force(self.ldb, "cn=ldaptestcontainer," + self.base_dn)
91 delete_force(self.ldb, "cn=ldaptestcontainer2," + self.base_dn)
92 delete_force(self.ldb, "cn=parentguidtest,cn=users," + self.base_dn)
93 delete_force(self.ldb, "cn=parentguidtest,cn=testotherusers," + self.base_dn)
94 delete_force(self.ldb, "cn=testotherusers," + self.base_dn)
95 delete_force(self.ldb, "cn=ldaptestobject," + self.base_dn)
96 delete_force(self.ldb, "description=xyz,cn=users," + self.base_dn)
97 delete_force(self.ldb, "ou=testou,cn=users," + self.base_dn)
98 delete_force(self.ldb, "cn=testsecret,cn=system," + self.base_dn)
100 def test_objectclasses(self):
101 """Test objectClass behaviour"""
102 print "Test objectClass behaviour"""
104 # We cannot create LSA-specific objects (oc "secret" or "trustedDomain")
107 "dn": "cn=testsecret,cn=system," + self.base_dn,
108 "objectClass": "secret" })
110 except LdbError, (num, _):
111 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
113 # Invalid objectclass specified
116 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
119 except LdbError, (num, _):
120 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
122 # Invalid objectclass specified
125 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
126 "objectClass": "X" })
128 except LdbError, (num, _):
129 self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
131 # Invalid objectCategory specified
134 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
135 "objectClass": "person",
136 "objectCategory": self.base_dn })
138 except LdbError, (num, _):
139 self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
141 # Multi-valued "systemFlags"
144 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
145 "objectClass": "person",
146 "systemFlags": ["0", str(SYSTEM_FLAG_DOMAIN_DISALLOW_MOVE)] })
148 except LdbError, (num, _):
149 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
151 # We cannot instanciate from an abstract objectclass
154 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
155 "objectClass": "connectionPoint" })
157 except LdbError, (num, _):
158 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
160 # Test allowed system flags
162 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
163 "objectClass": "person",
164 "systemFlags": str(~(SYSTEM_FLAG_CONFIG_ALLOW_RENAME | SYSTEM_FLAG_CONFIG_ALLOW_MOVE | SYSTEM_FLAG_CONFIG_ALLOW_LIMITED_MOVE)) })
166 res = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
167 scope=SCOPE_BASE, attrs=["systemFlags"])
168 self.assertTrue(len(res) == 1)
169 self.assertEquals(res[0]["systemFlags"][0], "0")
171 delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
174 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
175 "objectClass": "person" })
177 # We can remove derivation classes of the structural objectclass
178 # but they're going to be readded afterwards
180 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
181 m["objectClass"] = MessageElement("top", FLAG_MOD_DELETE,
185 res = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
186 scope=SCOPE_BASE, attrs=["objectClass"])
187 self.assertTrue(len(res) == 1)
188 self.assertTrue("top" in res[0]["objectClass"])
190 # The top-most structural class cannot be deleted since there are
191 # attributes of it in use
193 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
194 m["objectClass"] = MessageElement("person", FLAG_MOD_DELETE,
199 except LdbError, (num, _):
200 self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
202 # We cannot delete classes which weren't specified
204 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
205 m["objectClass"] = MessageElement("computer", FLAG_MOD_DELETE,
210 except LdbError, (num, _):
211 self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
213 # An invalid class cannot be added
215 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
216 m["objectClass"] = MessageElement("X", FLAG_MOD_ADD,
221 except LdbError, (num, _):
222 self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
224 # The top-most structural class cannot be changed by adding another
227 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
228 m["objectClass"] = MessageElement("user", FLAG_MOD_ADD,
233 except LdbError, (num, _):
234 self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
236 # An already specified objectclass cannot be added another time
238 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
239 m["objectClass"] = MessageElement("person", FLAG_MOD_ADD,
244 except LdbError, (num, _):
245 self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
247 # Auxiliary classes can always be added
249 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
250 m["objectClass"] = MessageElement("bootableDevice", FLAG_MOD_ADD,
254 # It's only possible to replace with the same objectclass combination.
255 # So the replace action on "objectClass" attributes is really useless.
257 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
258 m["objectClass"] = MessageElement(["top", "person", "bootableDevice"],
259 FLAG_MOD_REPLACE, "objectClass")
263 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
264 m["objectClass"] = MessageElement(["person", "bootableDevice"],
265 FLAG_MOD_REPLACE, "objectClass")
269 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
270 m["objectClass"] = MessageElement(["top", "person", "bootableDevice",
271 "connectionPoint"], FLAG_MOD_REPLACE, "objectClass")
275 except LdbError, (num, _):
276 self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
278 # More than one change operation is allowed
280 dn: cn=ldaptestuser,cn=users, """ + self.base_dn + """
283 objectClass: bootableDevice
285 objectClass: bootableDevice
288 # We cannot remove all object classes by an empty replace
290 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
291 m["objectClass"] = MessageElement([], FLAG_MOD_REPLACE, "objectClass")
295 except LdbError, (num, _):
296 self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
299 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
300 m["objectClass"] = MessageElement(["top", "computer"], FLAG_MOD_REPLACE,
305 except LdbError, (num, _):
306 self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
308 # Classes can be removed unless attributes of them are used.
310 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
311 m["objectClass"] = MessageElement("bootableDevice", FLAG_MOD_DELETE,
315 res = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
316 scope=SCOPE_BASE, attrs=["objectClass"])
317 self.assertTrue(len(res) == 1)
318 self.assertFalse("bootableDevice" in res[0]["objectClass"])
321 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
322 m["objectClass"] = MessageElement("bootableDevice", FLAG_MOD_ADD,
326 # Add an attribute specific to the "bootableDevice" class
328 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
329 m["bootParameter"] = MessageElement("test", FLAG_MOD_ADD,
333 # Classes can be removed unless attributes of them are used. Now there
334 # exist such attributes on the entry.
336 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
337 m["objectClass"] = MessageElement("bootableDevice", FLAG_MOD_DELETE,
342 except LdbError, (num, _):
343 self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
345 # Remove the previously specified attribute
347 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
348 m["bootParameter"] = MessageElement("test", FLAG_MOD_DELETE,
352 # Classes can be removed unless attributes of them are used.
354 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
355 m["objectClass"] = MessageElement("bootableDevice", FLAG_MOD_DELETE,
359 delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
361 def test_system_only(self):
362 """Test systemOnly objects"""
363 print "Test systemOnly objects"""
367 "dn": "cn=ldaptestobject," + self.base_dn,
368 "objectclass": "configuration"})
370 except LdbError, (num, _):
371 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
375 "dn": "cn=testsecret,cn=system," + self.base_dn,
376 "objectclass": "secret"})
378 except LdbError, (num, _):
379 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
381 delete_force(self.ldb, "cn=ldaptestobject," + self.base_dn)
382 delete_force(self.ldb, "cn=testsecret,cn=system," + self.base_dn)
386 "dn": "cn=ldaptestcontainer," + self.base_dn,
387 "objectclass": "container",
388 "isCriticalSystemObject": "TRUE"})
390 except LdbError, (num, _):
391 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
394 "dn": "cn=ldaptestcontainer," + self.base_dn,
395 "objectclass": "container"})
398 m.dn = Dn(ldb, "cn=ldaptestcontainer," + self.base_dn)
399 m["isCriticalSystemObject"] = MessageElement("TRUE", FLAG_MOD_REPLACE,
400 "isCriticalSystemObject")
404 except LdbError, (num, _):
405 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
407 delete_force(self.ldb, "cn=ldaptestcontainer," + self.base_dn)
409 # Proof if DC SAM object has "isCriticalSystemObject" set
410 res = self.ldb.search("", scope=SCOPE_BASE, attrs=["serverName"])
411 self.assertTrue(len(res) == 1)
412 self.assertTrue("serverName" in res[0])
413 res = self.ldb.search(res[0]["serverName"][0], scope=SCOPE_BASE,
414 attrs=["serverReference"])
415 self.assertTrue(len(res) == 1)
416 self.assertTrue("serverReference" in res[0])
417 res = self.ldb.search(res[0]["serverReference"][0], scope=SCOPE_BASE,
418 attrs=["isCriticalSystemObject"])
419 self.assertTrue(len(res) == 1)
420 self.assertTrue("isCriticalSystemObject" in res[0])
421 self.assertEquals(res[0]["isCriticalSystemObject"][0], "TRUE")
423 def test_invalid_parent(self):
424 """Test adding an object with invalid parent"""
425 print "Test adding an object with invalid parent"""
429 "dn": "cn=ldaptestgroup,cn=thisdoesnotexist123,"
431 "objectclass": "group"})
433 except LdbError, (num, _):
434 self.assertEquals(num, ERR_NO_SUCH_OBJECT)
436 delete_force(self.ldb, "cn=ldaptestgroup,cn=thisdoesnotexist123,"
441 "dn": "ou=testou,cn=users," + self.base_dn,
442 "objectclass": "organizationalUnit"})
444 except LdbError, (num, _):
445 self.assertEquals(num, ERR_NAMING_VIOLATION)
447 delete_force(self.ldb, "ou=testou,cn=users," + self.base_dn)
449 def test_invalid_attribute(self):
450 """Test invalid attributes on schema/objectclasses"""
451 print "Test invalid attributes on schema/objectclasses"""
453 # attributes not in schema test
459 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
460 "objectclass": "group",
461 "thisdoesnotexist": "x"})
463 except LdbError, (num, _):
464 self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
467 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
468 "objectclass": "group"})
473 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
474 m["thisdoesnotexist"] = MessageElement("x", FLAG_MOD_REPLACE,
479 except LdbError, (num, _):
480 self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
482 delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
484 # attributes not in objectclasses and mandatory attributes missing test
485 # Use here a non-SAM entry since it doesn't have special triggers
486 # associated which have an impact on the error results.
490 # mandatory attribute missing
493 "dn": "cn=ldaptestobject," + self.base_dn,
494 "objectclass": "ipProtocol"})
496 except LdbError, (num, _):
497 self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
499 # inadequate but schema-valid attribute specified
502 "dn": "cn=ldaptestobject," + self.base_dn,
503 "objectclass": "ipProtocol",
504 "ipProtocolNumber": "1",
507 except LdbError, (num, _):
508 self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
511 "dn": "cn=ldaptestobject," + self.base_dn,
512 "objectclass": "ipProtocol",
513 "ipProtocolNumber": "1"})
517 # inadequate but schema-valid attribute add trial
519 m.dn = Dn(ldb, "cn=ldaptestobject," + self.base_dn)
520 m["uid"] = MessageElement("0", FLAG_MOD_ADD, "uid")
524 except LdbError, (num, _):
525 self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
527 # mandatory attribute delete trial
529 m.dn = Dn(ldb, "cn=ldaptestobject," + self.base_dn)
530 m["ipProtocolNumber"] = MessageElement([], FLAG_MOD_DELETE,
535 except LdbError, (num, _):
536 self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
538 # mandatory attribute delete trial
540 m.dn = Dn(ldb, "cn=ldaptestobject," + self.base_dn)
541 m["ipProtocolNumber"] = MessageElement([], FLAG_MOD_REPLACE,
546 except LdbError, (num, _):
547 self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
549 delete_force(self.ldb, "cn=ldaptestobject," + self.base_dn)
551 def test_single_valued_attributes(self):
552 """Test single-valued attributes"""
553 print "Test single-valued attributes"""
557 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
558 "objectclass": "group",
559 "sAMAccountName": ["nam1", "nam2"]})
561 except LdbError, (num, _):
562 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
565 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
566 "objectclass": "group"})
569 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
570 m["sAMAccountName"] = MessageElement(["nam1","nam2"], FLAG_MOD_REPLACE,
575 except LdbError, (num, _):
576 self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
579 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
580 m["sAMAccountName"] = MessageElement("testgroupXX", FLAG_MOD_REPLACE,
585 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
586 m["sAMAccountName"] = MessageElement("testgroupXX2", FLAG_MOD_ADD,
591 except LdbError, (num, _):
592 self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
594 delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
596 def test_attribute_ranges(self):
597 """Test attribute ranges"""
598 print "Test attribute ranges"""
603 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
604 "objectClass": "person",
607 except LdbError, (num, _):
608 self.assertEquals(num, ERR_INVALID_ATTRIBUTE_SYNTAX)
613 # "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
614 # "objectClass": "person",
615 # "sn": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" })
617 # except LdbError, (num, _):
618 # self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
621 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
622 "objectClass": "person" })
626 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
627 m["sn"] = MessageElement("", FLAG_MOD_REPLACE, "sn")
631 except LdbError, (num, _):
632 self.assertEquals(num, ERR_INVALID_ATTRIBUTE_SYNTAX)
636 # m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
637 # m["sn"] = MessageElement("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", FLAG_MOD_REPLACE, "sn")
641 # except LdbError, (num, _):
642 # self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
645 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
646 m["sn"] = MessageElement("x", FLAG_MOD_REPLACE, "sn")
649 delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
651 def test_empty_messages(self):
652 """Test empty messages"""
653 print "Test empty messages"""
656 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
661 except LdbError, (num, _):
662 self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
667 except LdbError, (num, _):
668 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
670 delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
672 def test_empty_attributes(self):
673 """Test empty attributes"""
674 print "Test empty attributes"""
677 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
678 m["objectClass"] = MessageElement("group", FLAG_MOD_ADD, "objectClass")
679 m["description"] = MessageElement([], FLAG_MOD_ADD, "description")
684 except LdbError, (num, _):
685 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
688 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
689 "objectclass": "group"})
692 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
693 m["description"] = MessageElement([], FLAG_MOD_ADD, "description")
698 except LdbError, (num, _):
699 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
702 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
703 m["description"] = MessageElement([], FLAG_MOD_REPLACE, "description")
707 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
708 m["description"] = MessageElement([], FLAG_MOD_DELETE, "description")
712 except LdbError, (num, _):
713 self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
715 delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
717 def test_instanceType(self):
718 """Tests the 'instanceType' attribute"""
719 print "Tests the 'instanceType' attribute"""
721 # The instance type is single-valued
724 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
725 "objectclass": "group",
726 "instanceType": ["0", "1"]})
728 except LdbError, (num, _):
729 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
731 # The head NC flag cannot be set without the write flag
734 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
735 "objectclass": "group",
736 "instanceType": "1" })
738 except LdbError, (num, _):
739 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
741 # We cannot manipulate NCs without the head NC flag
744 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
745 "objectclass": "group",
746 "instanceType": "32" })
748 except LdbError, (num, _):
749 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
752 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
753 "objectclass": "group"})
756 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
757 m["instanceType"] = MessageElement("0", FLAG_MOD_REPLACE,
762 except LdbError, (num, _):
763 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
766 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
767 m["instanceType"] = MessageElement([], FLAG_MOD_REPLACE,
772 except LdbError, (num, _):
773 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
776 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
777 m["instanceType"] = MessageElement([], FLAG_MOD_DELETE, "instanceType")
781 except LdbError, (num, _):
782 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
784 delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
786 def test_distinguished_name(self):
787 """Tests the 'distinguishedName' attribute"""
788 print "Tests the 'distinguishedName' attribute"""
790 # The "dn" shortcut isn't supported
792 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
793 m["objectClass"] = MessageElement("group", 0, "objectClass")
794 m["dn"] = MessageElement("cn=ldaptestgroup,cn=users," + self.base_dn, 0,
799 except LdbError, (num, _):
800 self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
802 # a wrong "distinguishedName" attribute is obviously tolerated
804 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
805 "objectclass": "group",
806 "distinguishedName": "cn=ldaptest,cn=users," + self.base_dn})
808 # proof if the DN has been set correctly
809 res = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
810 scope=SCOPE_BASE, attrs=["distinguishedName"])
811 self.assertTrue(len(res) == 1)
812 self.assertTrue("distinguishedName" in res[0])
813 self.assertTrue(Dn(ldb, res[0]["distinguishedName"][0])
814 == Dn(ldb, "cn=ldaptestgroup, cn=users," + self.base_dn))
816 # The "dn" shortcut isn't supported
818 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
819 m["dn"] = MessageElement(
820 "cn=ldaptestgroup,cn=users," + self.base_dn, FLAG_MOD_REPLACE,
825 except LdbError, (num, _):
826 self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
829 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
830 m["distinguishedName"] = MessageElement(
831 "cn=ldaptestuser,cn=users," + self.base_dn, FLAG_MOD_ADD,
837 except LdbError, (num, _):
838 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
841 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
842 m["distinguishedName"] = MessageElement(
843 "cn=ldaptestuser,cn=users," + self.base_dn, FLAG_MOD_REPLACE,
849 except LdbError, (num, _):
850 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
853 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
854 m["distinguishedName"] = MessageElement(
855 "cn=ldaptestuser,cn=users," + self.base_dn, FLAG_MOD_DELETE,
861 except LdbError, (num, _):
862 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
864 delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
866 def test_rdn_name(self):
868 print "Tests the RDN"""
873 "dn": "=,cn=users," + self.base_dn,
874 "objectclass": "group"})
876 except LdbError, (num, _):
877 self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
882 "dn": "=ldaptestgroup,cn=users," + self.base_dn,
883 "objectclass": "group"})
885 except LdbError, (num, _):
886 self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
891 "dn": "cn=,cn=users," + self.base_dn,
892 "objectclass": "group"})
894 except LdbError, (num, _):
895 self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
897 # a wrong RDN candidate
900 "dn": "description=xyz,cn=users," + self.base_dn,
901 "objectclass": "group"})
903 except LdbError, (num, _):
904 self.assertEquals(num, ERR_NAMING_VIOLATION)
906 delete_force(self.ldb, "description=xyz,cn=users," + self.base_dn)
908 # a wrong "name" attribute is obviously tolerated
910 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
911 "objectclass": "group",
912 "name": "ldaptestgroupx"})
914 # proof if the name has been set correctly
915 res = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
916 scope=SCOPE_BASE, attrs=["name"])
917 self.assertTrue(len(res) == 1)
918 self.assertTrue("name" in res[0])
919 self.assertTrue(res[0]["name"][0] == "ldaptestgroup")
923 self.ldb.rename("cn=ldaptestgroup,cn=users," + self.base_dn,
924 "=,cn=users," + self.base_dn)
926 except LdbError, (num, _):
927 self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
931 self.ldb.rename("cn=ldaptestgroup,cn=users," + self.base_dn,
932 "=ldaptestgroup,cn=users," + self.base_dn)
934 except LdbError, (num, _):
935 self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
937 # new empty RDN value
939 self.ldb.rename("cn=ldaptestgroup,cn=users," + self.base_dn,
940 "cn=,cn=users," + self.base_dn)
942 except LdbError, (num, _):
943 self.assertEquals(num, ERR_NAMING_VIOLATION)
946 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
947 m["name"] = MessageElement("cn=ldaptestuser", FLAG_MOD_REPLACE,
952 except LdbError, (num, _):
953 self.assertEquals(num, ERR_NOT_ALLOWED_ON_RDN)
956 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
957 m["cn"] = MessageElement("ldaptestuser",
958 FLAG_MOD_REPLACE, "cn")
962 except LdbError, (num, _):
963 self.assertEquals(num, ERR_NOT_ALLOWED_ON_RDN)
965 delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
968 # this test needs to be disabled until we really understand
969 # what the rDN length constraints are
970 def DISABLED_test_largeRDN(self):
971 """Testing large rDN (limit 64 characters)"""
972 rdn = "CN=a012345678901234567890123456789012345678901234567890123456789012";
973 delete_force(self.ldb, "%s,%s" % (rdn, self.base_dn))
975 dn: %s,%s""" % (rdn,self.base_dn) + """
976 objectClass: container
978 self.ldb.add_ldif(ldif)
979 delete_force(self.ldb, "%s,%s" % (rdn, self.base_dn))
981 rdn = "CN=a0123456789012345678901234567890123456789012345678901234567890120";
982 delete_force(self.ldb, "%s,%s" % (rdn, self.base_dn))
985 dn: %s,%s""" % (rdn,self.base_dn) + """
986 objectClass: container
988 self.ldb.add_ldif(ldif)
990 except LdbError, (num, _):
991 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
992 delete_force(self.ldb, "%s,%s" % (rdn, self.base_dn))
994 def test_rename(self):
995 """Tests the rename operation"""
996 print "Tests the rename operations"""
999 # cannot rename to be a child of itself
1000 ldb.rename(self.base_dn, "dc=test," + self.base_dn)
1002 except LdbError, (num, _):
1003 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1007 ldb.rename("cn=ldaptestuser2,cn=users," + self.base_dn, "cn=ldaptestuser2,cn=users," + self.base_dn)
1009 except LdbError, (num, _):
1010 self.assertEquals(num, ERR_NO_SUCH_OBJECT)
1013 "dn": "cn=ldaptestuser2,cn=users," + self.base_dn,
1014 "objectclass": "user" })
1016 ldb.rename("cn=ldaptestuser2,cn=users," + self.base_dn, "cn=ldaptestuser2,cn=users," + self.base_dn)
1017 ldb.rename("cn=ldaptestuser2,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=users," + self.base_dn)
1018 ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestUSER3,cn=users," + self.base_dn)
1021 # containment problem: a user entry cannot contain user entries
1022 ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser4,cn=ldaptestuser3,cn=users," + self.base_dn)
1024 except LdbError, (num, _):
1025 self.assertEquals(num, ERR_NAMING_VIOLATION)
1029 ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=people,cn=users," + self.base_dn)
1031 except LdbError, (num, _):
1032 self.assertEquals(num, ERR_OTHER)
1035 # invalid target DN syntax
1036 ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, ",cn=users," + self.base_dn)
1038 except LdbError, (num, _):
1039 self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
1043 ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "ou=ldaptestuser3,cn=users," + self.base_dn)
1045 except LdbError, (num, _):
1046 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1048 delete_force(self.ldb, "cn=ldaptestuser3,cn=users," + self.base_dn)
1050 # Performs some "systemFlags" testing
1052 # Move failing since no "SYSTEM_FLAG_CONFIG_ALLOW_MOVE"
1054 ldb.rename("CN=DisplaySpecifiers," + self.configuration_dn, "CN=DisplaySpecifiers,CN=Services," + self.configuration_dn)
1056 except LdbError, (num, _):
1057 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1059 # Limited move failing since no "SYSTEM_FLAG_CONFIG_ALLOW_LIMITED_MOVE"
1061 ldb.rename("CN=Directory Service,CN=Windows NT,CN=Services," + self.configuration_dn, "CN=Directory Service,CN=RRAS,CN=Services," + self.configuration_dn)
1063 except LdbError, (num, _):
1064 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1066 # Rename failing since no "SYSTEM_FLAG_CONFIG_ALLOW_RENAME"
1068 ldb.rename("CN=DisplaySpecifiers," + self.configuration_dn, "CN=DisplaySpecifiers2," + self.configuration_dn)
1070 except LdbError, (num, _):
1071 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1073 # It's not really possible to test moves on the schema partition since
1074 # there don't exist subcontainers on it.
1076 # Rename failing since "SYSTEM_FLAG_SCHEMA_BASE_OBJECT"
1078 ldb.rename("CN=Top," + self.schema_dn, "CN=Top2," + self.schema_dn)
1080 except LdbError, (num, _):
1081 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1083 # Move failing since "SYSTEM_FLAG_DOMAIN_DISALLOW_MOVE"
1085 ldb.rename("CN=Users," + self.base_dn, "CN=Users,CN=Computers," + self.base_dn)
1087 except LdbError, (num, _):
1088 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1090 # Rename failing since "SYSTEM_FLAG_DOMAIN_DISALLOW_RENAME"
1092 ldb.rename("CN=Users," + self.base_dn, "CN=Users2," + self.base_dn)
1094 except LdbError, (num, _):
1095 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1097 # Performs some other constraints testing
1100 ldb.rename("CN=Policies,CN=System," + self.base_dn, "CN=Users2," + self.base_dn)
1102 except LdbError, (num, _):
1103 self.assertEquals(num, ERR_OTHER)
1105 def test_rename_twice(self):
1106 """Tests the rename operation twice - this corresponds to a past bug"""
1107 print "Tests the rename twice operation"""
1110 "dn": "cn=ldaptestuser5,cn=users," + self.base_dn,
1111 "objectclass": "user" })
1113 ldb.rename("cn=ldaptestuser5,cn=users," + self.base_dn, "cn=ldaptestUSER5,cn=users," + self.base_dn)
1114 delete_force(self.ldb, "cn=ldaptestuser5,cn=users," + self.base_dn)
1116 "dn": "cn=ldaptestuser5,cn=users," + self.base_dn,
1117 "objectclass": "user" })
1118 ldb.rename("cn=ldaptestuser5,cn=Users," + self.base_dn, "cn=ldaptestUSER5,cn=users," + self.base_dn)
1119 res = ldb.search(expression="cn=ldaptestuser5")
1120 print "Found %u records" % len(res)
1121 self.assertEquals(len(res), 1, "Wrong number of hits for cn=ldaptestuser5")
1122 res = ldb.search(expression="(&(cn=ldaptestuser5)(objectclass=user))")
1123 print "Found %u records" % len(res)
1124 self.assertEquals(len(res), 1, "Wrong number of hits for (&(cn=ldaptestuser5)(objectclass=user))")
1125 delete_force(self.ldb, "cn=ldaptestuser5,cn=users," + self.base_dn)
1127 def test_objectGUID(self):
1128 """Test objectGUID behaviour"""
1129 print "Testing objectGUID behaviour\n"
1131 # The objectGUID cannot directly be set
1133 self.ldb.add_ldif("""
1134 dn: cn=ldaptestcontainer,""" + self.base_dn + """
1135 objectClass: container
1136 objectGUID: bd3480c9-58af-4cd8-92df-bc4a18b6e44d
1139 except LdbError, (num, _):
1140 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1143 "dn": "cn=ldaptestcontainer," + self.base_dn,
1144 "objectClass": "container" })
1146 res = ldb.search("cn=ldaptestcontainer," + self.base_dn,
1148 attrs=["objectGUID", "uSNCreated", "uSNChanged", "whenCreated", "whenChanged"])
1149 self.assertTrue(len(res) == 1)
1150 self.assertTrue("objectGUID" in res[0])
1151 self.assertTrue("uSNCreated" in res[0])
1152 self.assertTrue("uSNChanged" in res[0])
1153 self.assertTrue("whenCreated" in res[0])
1154 self.assertTrue("whenChanged" in res[0])
1156 delete_force(self.ldb, "cn=ldaptestcontainer," + self.base_dn)
1158 # All the following attributes are specificable on add operations
1160 "dn": "cn=ldaptestcontainer," + self.base_dn,
1161 "objectClass": "container",
1164 "whenCreated": timestring(long(time.time())),
1165 "whenChanged": timestring(long(time.time())) })
1167 res = ldb.search("cn=ldaptestcontainer," + self.base_dn,
1169 attrs=["objectGUID", "uSNCreated", "uSNChanged", "whenCreated", "whenChanged"])
1170 self.assertTrue(len(res) == 1)
1171 self.assertTrue("objectGUID" in res[0])
1172 self.assertTrue("uSNCreated" in res[0])
1173 self.assertFalse(res[0]["uSNCreated"][0] == "1") # these are corrected
1174 self.assertTrue("uSNChanged" in res[0])
1175 self.assertFalse(res[0]["uSNChanged"][0] == "1") # these are corrected
1177 delete_force(self.ldb, "cn=ldaptestcontainer," + self.base_dn)
1179 # All this attributes are specificable on add operations
1181 "dn": "cn=ldaptestcontainer," + self.base_dn,
1182 "objectclass": "container",
1185 "whenCreated": timestring(long(time.time())),
1186 "whenChanged": timestring(long(time.time())) })
1188 res = ldb.search("cn=ldaptestcontainer," + self.base_dn,
1190 attrs=["objectGUID", "uSNCreated", "uSNChanged", "whenCreated", "whenChanged"])
1191 self.assertTrue(len(res) == 1)
1192 self.assertTrue("objectGUID" in res[0])
1193 self.assertTrue("uSNCreated" in res[0])
1194 self.assertFalse(res[0]["uSNCreated"][0] == "1") # these are corrected
1195 self.assertTrue("uSNChanged" in res[0])
1196 self.assertFalse(res[0]["uSNChanged"][0] == "1") # these are corrected
1197 self.assertTrue("whenCreated" in res[0])
1198 self.assertTrue("whenChanged" in res[0])
1200 # The objectGUID cannot directly be changed
1202 self.ldb.modify_ldif("""
1203 dn: cn=ldaptestcontainer,""" + self.base_dn + """
1206 objectGUID: bd3480c9-58af-4cd8-92df-bc4a18b6e44d
1209 except LdbError, (num, _):
1210 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
1212 delete_force(self.ldb, "cn=ldaptestcontainer," + self.base_dn)
1214 def test_parentGUID(self):
1215 """Test parentGUID behaviour"""
1216 print "Testing parentGUID behaviour\n"
1219 "dn": "cn=parentguidtest,cn=users," + self.base_dn,
1220 "objectclass":"user",
1221 "samaccountname":"parentguidtest"});
1222 res1 = ldb.search(base="cn=parentguidtest,cn=users," + self.base_dn, scope=SCOPE_BASE,
1223 attrs=["parentGUID", "samaccountname"]);
1224 res2 = ldb.search(base="cn=users," + self.base_dn,scope=SCOPE_BASE,
1225 attrs=["objectGUID"]);
1226 res3 = ldb.search(base=self.base_dn, scope=SCOPE_BASE,
1227 attrs=["parentGUID"]);
1228 res4 = ldb.search(base=self.configuration_dn, scope=SCOPE_BASE,
1229 attrs=["parentGUID"]);
1230 res5 = ldb.search(base=self.schema_dn, scope=SCOPE_BASE,
1231 attrs=["parentGUID"]);
1233 """Check if the parentGUID is valid """
1234 self.assertEquals(res1[0]["parentGUID"], res2[0]["objectGUID"]);
1236 """Check if it returns nothing when there is no parent object - default NC"""
1237 has_parentGUID = False
1238 for key in res3[0].keys():
1239 if key == "parentGUID":
1240 has_parentGUID = True
1242 self.assertFalse(has_parentGUID);
1244 """Check if it returns nothing when there is no parent object - configuration NC"""
1245 has_parentGUID = False
1246 for key in res4[0].keys():
1247 if key == "parentGUID":
1248 has_parentGUID = True
1250 self.assertFalse(has_parentGUID);
1252 """Check if it returns nothing when there is no parent object - schema NC"""
1253 has_parentGUID = False
1254 for key in res5[0].keys():
1255 if key == "parentGUID":
1256 has_parentGUID = True
1258 self.assertFalse(has_parentGUID);
1260 """Ensures that if you look for another object attribute after the constructed
1261 parentGUID, it will return correctly"""
1262 has_another_attribute = False
1263 for key in res1[0].keys():
1264 if key == "sAMAccountName":
1265 has_another_attribute = True
1267 self.assertTrue(has_another_attribute)
1268 self.assertTrue(len(res1[0]["samaccountname"]) == 1)
1269 self.assertEquals(res1[0]["samaccountname"][0], "parentguidtest");
1271 print "Testing parentGUID behaviour on rename\n"
1274 "dn": "cn=testotherusers," + self.base_dn,
1275 "objectclass":"container"});
1276 res1 = ldb.search(base="cn=testotherusers," + self.base_dn,scope=SCOPE_BASE,
1277 attrs=["objectGUID"]);
1278 ldb.rename("cn=parentguidtest,cn=users," + self.base_dn,
1279 "cn=parentguidtest,cn=testotherusers," + self.base_dn);
1280 res2 = ldb.search(base="cn=parentguidtest,cn=testotherusers," + self.base_dn,
1282 attrs=["parentGUID"]);
1283 self.assertEquals(res1[0]["objectGUID"], res2[0]["parentGUID"]);
1285 delete_force(self.ldb, "cn=parentguidtest,cn=testotherusers," + self.base_dn)
1286 delete_force(self.ldb, "cn=testotherusers," + self.base_dn)
1288 def test_groupType_int32(self):
1289 """Test groupType (int32) behaviour (should appear to be casted to a 32 bit signed integer before comparsion)"""
1290 print "Testing groupType (int32) behaviour\n"
1292 res1 = ldb.search(base=self.base_dn, scope=SCOPE_SUBTREE,
1293 attrs=["groupType"], expression="groupType=2147483653");
1295 res2 = ldb.search(base=self.base_dn, scope=SCOPE_SUBTREE,
1296 attrs=["groupType"], expression="groupType=-2147483643");
1298 self.assertEquals(len(res1), len(res2))
1300 self.assertTrue(res1.count > 0)
1302 self.assertEquals(res1[0]["groupType"][0], "-2147483643")
1304 def test_linked_attributes(self):
1305 """This tests the linked attribute behaviour"""
1306 print "Testing linked attribute behaviour\n"
1309 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
1310 "objectclass": "group"})
1312 # This should not work since "memberOf" is linked to "member"
1315 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
1316 "objectclass": "user",
1317 "memberOf": "cn=ldaptestgroup,cn=users," + self.base_dn})
1318 except LdbError, (num, _):
1319 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1322 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
1323 "objectclass": "user"})
1326 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1327 m["memberOf"] = MessageElement("cn=ldaptestgroup,cn=users," + self.base_dn,
1328 FLAG_MOD_ADD, "memberOf")
1332 except LdbError, (num, _):
1333 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1336 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1337 m["member"] = MessageElement("cn=ldaptestuser,cn=users," + self.base_dn,
1338 FLAG_MOD_ADD, "member")
1342 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1343 m["memberOf"] = MessageElement("cn=ldaptestgroup,cn=users," + self.base_dn,
1344 FLAG_MOD_REPLACE, "memberOf")
1348 except LdbError, (num, _):
1349 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1352 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1353 m["memberOf"] = MessageElement("cn=ldaptestgroup,cn=users," + self.base_dn,
1354 FLAG_MOD_DELETE, "memberOf")
1358 except LdbError, (num, _):
1359 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1362 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1363 m["member"] = MessageElement("cn=ldaptestuser,cn=users," + self.base_dn,
1364 FLAG_MOD_DELETE, "member")
1367 # This should yield no results since the member attribute for
1368 # "ldaptestuser" should have been deleted
1369 res1 = ldb.search("cn=ldaptestgroup, cn=users," + self.base_dn,
1371 expression="(member=cn=ldaptestuser,cn=users," + self.base_dn + ")",
1373 self.assertTrue(len(res1) == 0)
1375 delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1378 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
1379 "objectclass": "group",
1380 "member": "cn=ldaptestuser,cn=users," + self.base_dn})
1382 delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1384 # Make sure that the "member" attribute for "ldaptestuser" has been
1386 res = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
1387 scope=SCOPE_BASE, attrs=["member"])
1388 self.assertTrue(len(res) == 1)
1389 self.assertFalse("member" in res[0])
1391 delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1393 def test_wkguid(self):
1394 """Test Well known GUID behaviours (including DN+Binary)"""
1395 print "Test Well known GUID behaviours (including DN+Binary)"""
1397 res = self.ldb.search(base=("<WKGUID=ab1d30f3768811d1aded00c04fd8d5cd,%s>" % self.base_dn), scope=SCOPE_BASE, attrs=[])
1398 self.assertEquals(len(res), 1)
1400 res2 = self.ldb.search(scope=SCOPE_BASE, attrs=["wellKnownObjects"], expression=("wellKnownObjects=B:32:ab1d30f3768811d1aded00c04fd8d5cd:%s" % res[0].dn))
1401 self.assertEquals(len(res2), 1)
1403 # Prove that the matching rule is over the whole DN+Binary
1404 res2 = self.ldb.search(scope=SCOPE_BASE, attrs=["wellKnownObjects"], expression=("wellKnownObjects=B:32:ab1d30f3768811d1aded00c04fd8d5cd"))
1405 self.assertEquals(len(res2), 0)
1406 # Prove that the matching rule is over the whole DN+Binary
1407 res2 = self.ldb.search(scope=SCOPE_BASE, attrs=["wellKnownObjects"], expression=("wellKnownObjects=%s") % res[0].dn)
1408 self.assertEquals(len(res2), 0)
1410 def test_subschemasubentry(self):
1411 """Test subSchemaSubEntry appears when requested, but not when not requested"""
1412 print "Test subSchemaSubEntry"""
1414 res = self.ldb.search(base=self.base_dn, scope=SCOPE_BASE, attrs=["subSchemaSubEntry"])
1415 self.assertEquals(len(res), 1)
1416 self.assertEquals(res[0]["subSchemaSubEntry"][0], "CN=Aggregate,"+self.schema_dn)
1418 res = self.ldb.search(base=self.base_dn, scope=SCOPE_BASE, attrs=["*"])
1419 self.assertEquals(len(res), 1)
1420 self.assertTrue("subScheamSubEntry" not in res[0])
1425 print "Testing user add"
1428 "dn": "cn=ldaptestuser,cn=uSers," + self.base_dn,
1429 "objectclass": "user",
1430 "cN": "LDAPtestUSER",
1431 "givenname": "ldap",
1435 "dn": "cn=ldaptestgroup,cn=uSers," + self.base_dn,
1436 "objectclass": "group",
1437 "member": "cn=ldaptestuser,cn=useRs," + self.base_dn})
1440 "dn": "cn=ldaptestcomputer,cn=computers," + self.base_dn,
1441 "objectclass": "computer",
1442 "cN": "LDAPtestCOMPUTER"})
1444 ldb.add({"dn": "cn=ldaptest2computer,cn=computers," + self.base_dn,
1445 "objectClass": "computer",
1446 "cn": "LDAPtest2COMPUTER",
1447 "userAccountControl": str(UF_WORKSTATION_TRUST_ACCOUNT),
1448 "displayname": "ldap testy"})
1451 ldb.add({"dn": "cn=ldaptestcomputer3,cn=computers," + self.base_dn,
1452 "objectClass": "computer",
1453 "cn": "LDAPtest2COMPUTER"
1456 except LdbError, (num, _):
1457 self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
1460 ldb.add({"dn": "cn=ldaptestcomputer3,cn=computers," + self.base_dn,
1461 "objectClass": "computer",
1462 "cn": "ldaptestcomputer3",
1463 "sAMAccountType": str(ATYPE_NORMAL_ACCOUNT)
1466 except LdbError, (num, _):
1467 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1469 ldb.add({"dn": "cn=ldaptestcomputer3,cn=computers," + self.base_dn,
1470 "objectClass": "computer",
1471 "cn": "LDAPtestCOMPUTER3"
1474 print "Testing ldb.search for (&(cn=ldaptestcomputer3)(objectClass=user))";
1475 res = ldb.search(self.base_dn, expression="(&(cn=ldaptestcomputer3)(objectClass=user))");
1476 self.assertEquals(len(res), 1, "Found only %d for (&(cn=ldaptestcomputer3)(objectClass=user))" % len(res))
1478 self.assertEquals(str(res[0].dn), ("CN=ldaptestcomputer3,CN=Computers," + self.base_dn));
1479 self.assertEquals(res[0]["cn"][0], "ldaptestcomputer3");
1480 self.assertEquals(res[0]["name"][0], "ldaptestcomputer3");
1481 self.assertEquals(res[0]["objectClass"][0], "top");
1482 self.assertEquals(res[0]["objectClass"][1], "person");
1483 self.assertEquals(res[0]["objectClass"][2], "organizationalPerson");
1484 self.assertEquals(res[0]["objectClass"][3], "user");
1485 self.assertEquals(res[0]["objectClass"][4], "computer");
1486 self.assertTrue("objectGUID" in res[0])
1487 self.assertTrue("whenCreated" in res[0])
1488 self.assertEquals(res[0]["objectCategory"][0], ("CN=Computer,CN=Schema,CN=Configuration," + self.base_dn));
1489 self.assertEquals(int(res[0]["primaryGroupID"][0]), 513);
1490 self.assertEquals(int(res[0]["sAMAccountType"][0]), ATYPE_NORMAL_ACCOUNT);
1491 self.assertEquals(int(res[0]["userAccountControl"][0]), UF_NORMAL_ACCOUNT | UF_PASSWD_NOTREQD | UF_ACCOUNTDISABLE);
1493 delete_force(self.ldb, "cn=ldaptestcomputer3,cn=computers," + self.base_dn)
1495 print "Testing attribute or value exists behaviour"
1498 dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """
1500 replace: servicePrincipalName
1501 servicePrincipalName: host/ldaptest2computer
1502 servicePrincipalName: host/ldaptest2computer
1503 servicePrincipalName: cifs/ldaptest2computer
1506 except LdbError, (num, msg):
1507 self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
1510 dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """
1512 replace: servicePrincipalName
1513 servicePrincipalName: host/ldaptest2computer
1514 servicePrincipalName: cifs/ldaptest2computer
1518 dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """
1520 add: servicePrincipalName
1521 servicePrincipalName: host/ldaptest2computer
1524 except LdbError, (num, msg):
1525 self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
1527 print "Testing ranged results"
1529 dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """
1531 replace: servicePrincipalName
1535 dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """
1537 add: servicePrincipalName
1538 servicePrincipalName: host/ldaptest2computer0
1539 servicePrincipalName: host/ldaptest2computer1
1540 servicePrincipalName: host/ldaptest2computer2
1541 servicePrincipalName: host/ldaptest2computer3
1542 servicePrincipalName: host/ldaptest2computer4
1543 servicePrincipalName: host/ldaptest2computer5
1544 servicePrincipalName: host/ldaptest2computer6
1545 servicePrincipalName: host/ldaptest2computer7
1546 servicePrincipalName: host/ldaptest2computer8
1547 servicePrincipalName: host/ldaptest2computer9
1548 servicePrincipalName: host/ldaptest2computer10
1549 servicePrincipalName: host/ldaptest2computer11
1550 servicePrincipalName: host/ldaptest2computer12
1551 servicePrincipalName: host/ldaptest2computer13
1552 servicePrincipalName: host/ldaptest2computer14
1553 servicePrincipalName: host/ldaptest2computer15
1554 servicePrincipalName: host/ldaptest2computer16
1555 servicePrincipalName: host/ldaptest2computer17
1556 servicePrincipalName: host/ldaptest2computer18
1557 servicePrincipalName: host/ldaptest2computer19
1558 servicePrincipalName: host/ldaptest2computer20
1559 servicePrincipalName: host/ldaptest2computer21
1560 servicePrincipalName: host/ldaptest2computer22
1561 servicePrincipalName: host/ldaptest2computer23
1562 servicePrincipalName: host/ldaptest2computer24
1563 servicePrincipalName: host/ldaptest2computer25
1564 servicePrincipalName: host/ldaptest2computer26
1565 servicePrincipalName: host/ldaptest2computer27
1566 servicePrincipalName: host/ldaptest2computer28
1567 servicePrincipalName: host/ldaptest2computer29
1570 res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE,
1571 attrs=["servicePrincipalName;range=0-*"])
1572 self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
1573 #print len(res[0]["servicePrincipalName;range=0-*"])
1574 self.assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30)
1576 res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-19"])
1577 self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
1578 # print res[0]["servicePrincipalName;range=0-19"].length
1579 self.assertEquals(len(res[0]["servicePrincipalName;range=0-19"]), 20)
1582 res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-30"])
1583 self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
1584 self.assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30)
1586 res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-40"])
1587 self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
1588 self.assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30)
1590 res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=30-40"])
1591 self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
1592 self.assertEquals(len(res[0]["servicePrincipalName;range=30-*"]), 0)
1595 res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=10-40"])
1596 self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
1597 self.assertEquals(len(res[0]["servicePrincipalName;range=10-*"]), 20)
1598 # pos_11 = res[0]["servicePrincipalName;range=10-*"][18]
1600 res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=11-40"])
1601 self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
1602 self.assertEquals(len(res[0]["servicePrincipalName;range=11-*"]), 19)
1603 # print res[0]["servicePrincipalName;range=11-*"][18]
1605 # self.assertEquals((res[0]["servicePrincipalName;range=11-*"][18]), pos_11)
1607 res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=11-15"])
1608 self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
1609 self.assertEquals(len(res[0]["servicePrincipalName;range=11-15"]), 5)
1610 # self.assertEquals(res[0]["servicePrincipalName;range=11-15"][4], pos_11)
1612 res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName"])
1613 self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
1614 # print res[0]["servicePrincipalName"][18]
1616 self.assertEquals(len(res[0]["servicePrincipalName"]), 30)
1617 # self.assertEquals(res[0]["servicePrincipalName"][18], pos_11)
1619 delete_force(self.ldb, "cn=ldaptestuser2,cn=users," + self.base_dn)
1621 "dn": "cn=ldaptestuser2,cn=useRs," + self.base_dn,
1622 "objectClass": "user",
1623 "cn": "LDAPtestUSER2",
1624 "givenname": "testy",
1625 "sn": "ldap user2"})
1627 print "Testing Ambigious Name Resolution"
1628 # Testing ldb.search for (&(anr=ldap testy)(objectClass=user))
1629 res = ldb.search(expression="(&(anr=ldap testy)(objectClass=user))")
1630 self.assertEquals(len(res), 3, "Found only %d of 3 for (&(anr=ldap testy)(objectClass=user))" % len(res))
1632 # Testing ldb.search for (&(anr=testy ldap)(objectClass=user))
1633 res = ldb.search(expression="(&(anr=testy ldap)(objectClass=user))")
1634 self.assertEquals(len(res), 2, "Found only %d of 2 for (&(anr=testy ldap)(objectClass=user))" % len(res))
1636 # Testing ldb.search for (&(anr=ldap)(objectClass=user))
1637 res = ldb.search(expression="(&(anr=ldap)(objectClass=user))")
1638 self.assertEquals(len(res), 4, "Found only %d of 4 for (&(anr=ldap)(objectClass=user))" % len(res))
1640 # Testing ldb.search for (&(anr==ldap)(objectClass=user))
1641 res = ldb.search(expression="(&(anr==ldap)(objectClass=user))")
1642 self.assertEquals(len(res), 1, "Could not find (&(anr==ldap)(objectClass=user)). Found only %d for (&(anr=ldap)(objectClass=user))" % len(res))
1644 self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn))
1645 self.assertEquals(res[0]["cn"][0], "ldaptestuser")
1646 self.assertEquals(str(res[0]["name"]), "ldaptestuser")
1648 # Testing ldb.search for (&(anr=testy)(objectClass=user))
1649 res = ldb.search(expression="(&(anr=testy)(objectClass=user))")
1650 self.assertEquals(len(res), 2, "Found only %d for (&(anr=testy)(objectClass=user))" % len(res))
1652 # Testing ldb.search for (&(anr=testy ldap)(objectClass=user))
1653 res = ldb.search(expression="(&(anr=testy ldap)(objectClass=user))")
1654 self.assertEquals(len(res), 2, "Found only %d for (&(anr=testy ldap)(objectClass=user))" % len(res))
1656 # Testing ldb.search for (&(anr==testy ldap)(objectClass=user))
1657 # this test disabled for the moment, as anr with == tests are not understood
1658 # res = ldb.search(expression="(&(anr==testy ldap)(objectClass=user))")
1659 # self.assertEquals(len(res), 1, "Found only %d for (&(anr==testy ldap)(objectClass=user))" % len(res))
1661 # self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn))
1662 # self.assertEquals(res[0]["cn"][0], "ldaptestuser")
1663 # self.assertEquals(res[0]["name"][0], "ldaptestuser")
1665 # Testing ldb.search for (&(anr==testy ldap)(objectClass=user))
1666 # res = ldb.search(expression="(&(anr==testy ldap)(objectClass=user))")
1667 # self.assertEquals(len(res), 1, "Could not find (&(anr==testy ldap)(objectClass=user))")
1669 # self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn))
1670 # self.assertEquals(res[0]["cn"][0], "ldaptestuser")
1671 # self.assertEquals(res[0]["name"][0], "ldaptestuser")
1673 # Testing ldb.search for (&(anr=testy ldap user)(objectClass=user))
1674 res = ldb.search(expression="(&(anr=testy ldap user)(objectClass=user))")
1675 self.assertEquals(len(res), 1, "Could not find (&(anr=testy ldap user)(objectClass=user))")
1677 self.assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
1678 self.assertEquals(str(res[0]["cn"]), "ldaptestuser2")
1679 self.assertEquals(str(res[0]["name"]), "ldaptestuser2")
1681 # Testing ldb.search for (&(anr==testy ldap user2)(objectClass=user))
1682 # res = ldb.search(expression="(&(anr==testy ldap user2)(objectClass=user))")
1683 # self.assertEquals(len(res), 1, "Could not find (&(anr==testy ldap user2)(objectClass=user))")
1685 self.assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
1686 self.assertEquals(str(res[0]["cn"]), "ldaptestuser2")
1687 self.assertEquals(str(res[0]["name"]), "ldaptestuser2")
1689 # Testing ldb.search for (&(anr==ldap user2)(objectClass=user))
1690 # res = ldb.search(expression="(&(anr==ldap user2)(objectClass=user))")
1691 # self.assertEquals(len(res), 1, "Could not find (&(anr==ldap user2)(objectClass=user))")
1693 self.assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
1694 self.assertEquals(str(res[0]["cn"]), "ldaptestuser2")
1695 self.assertEquals(str(res[0]["name"]), "ldaptestuser2")
1697 # Testing ldb.search for (&(anr==not ldap user2)(objectClass=user))
1698 # res = ldb.search(expression="(&(anr==not ldap user2)(objectClass=user))")
1699 # self.assertEquals(len(res), 0, "Must not find (&(anr==not ldap user2)(objectClass=user))")
1701 # Testing ldb.search for (&(anr=not ldap user2)(objectClass=user))
1702 res = ldb.search(expression="(&(anr=not ldap user2)(objectClass=user))")
1703 self.assertEquals(len(res), 0, "Must not find (&(anr=not ldap user2)(objectClass=user))")
1705 # Testing ldb.search for (&(anr="testy ldap")(objectClass=user)) (ie, with quotes)
1706 # res = ldb.search(expression="(&(anr==\"testy ldap\")(objectClass=user))")
1707 # self.assertEquals(len(res), 0, "Found (&(anr==\"testy ldap\")(objectClass=user))")
1709 print "Testing Renames"
1711 attrs = ["objectGUID", "objectSid"]
1712 print "Testing ldb.search for (&(cn=ldaptestUSer2)(objectClass=user))"
1713 res_user = ldb.search(self.base_dn, expression="(&(cn=ldaptestUSer2)(objectClass=user))", scope=SCOPE_SUBTREE, attrs=attrs)
1714 self.assertEquals(len(res_user), 1, "Could not find (&(cn=ldaptestUSer2)(objectClass=user))")
1716 # Check rename works with extended/alternate DN forms
1717 ldb.rename("<SID=" + ldb.schema_format_value("objectSID", res_user[0]["objectSID"][0]) + ">" , "cn=ldaptestUSER3,cn=users," + self.base_dn)
1719 print "Testing ldb.search for (&(cn=ldaptestuser3)(objectClass=user))"
1720 res = ldb.search(expression="(&(cn=ldaptestuser3)(objectClass=user))")
1721 self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser3)(objectClass=user))")
1723 self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
1724 self.assertEquals(str(res[0]["cn"]), "ldaptestUSER3")
1725 self.assertEquals(str(res[0]["name"]), "ldaptestUSER3")
1727 #"Testing ldb.search for (&(&(cn=ldaptestuser3)(userAccountControl=*))(objectClass=user))"
1728 res = ldb.search(expression="(&(&(cn=ldaptestuser3)(userAccountControl=*))(objectClass=user))")
1729 self.assertEquals(len(res), 1, "(&(&(cn=ldaptestuser3)(userAccountControl=*))(objectClass=user))")
1731 self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
1732 self.assertEquals(str(res[0]["cn"]), "ldaptestUSER3")
1733 self.assertEquals(str(res[0]["name"]), "ldaptestUSER3")
1735 #"Testing ldb.search for (&(&(cn=ldaptestuser3)(userAccountControl=546))(objectClass=user))"
1736 res = ldb.search(expression="(&(&(cn=ldaptestuser3)(userAccountControl=546))(objectClass=user))")
1737 self.assertEquals(len(res), 1, "(&(&(cn=ldaptestuser3)(userAccountControl=546))(objectClass=user))")
1739 self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
1740 self.assertEquals(str(res[0]["cn"]), "ldaptestUSER3")
1741 self.assertEquals(str(res[0]["name"]), "ldaptestUSER3")
1743 #"Testing ldb.search for (&(&(cn=ldaptestuser3)(userAccountControl=547))(objectClass=user))"
1744 res = ldb.search(expression="(&(&(cn=ldaptestuser3)(userAccountControl=547))(objectClass=user))")
1745 self.assertEquals(len(res), 0, "(&(&(cn=ldaptestuser3)(userAccountControl=547))(objectClass=user))")
1747 # This is a Samba special, and does not exist in real AD
1748 # print "Testing ldb.search for (dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")"
1749 # res = ldb.search("(dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")")
1750 # if (res.error != 0 || len(res) != 1) {
1751 # print "Could not find (dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")"
1752 # self.assertEquals(len(res), 1)
1754 # self.assertEquals(res[0].dn, ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
1755 # self.assertEquals(res[0].cn, "ldaptestUSER3")
1756 # self.assertEquals(res[0].name, "ldaptestUSER3")
1758 print "Testing ldb.search for (distinguishedName=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")"
1759 res = ldb.search(expression="(distinguishedName=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")")
1760 self.assertEquals(len(res), 1, "Could not find (dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")")
1761 self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
1762 self.assertEquals(str(res[0]["cn"]), "ldaptestUSER3")
1763 self.assertEquals(str(res[0]["name"]), "ldaptestUSER3")
1765 # ensure we cannot add it again
1767 ldb.add({"dn": "cn=ldaptestuser3,cn=userS," + self.base_dn,
1768 "objectClass": "user",
1769 "cn": "LDAPtestUSER3"})
1771 except LdbError, (num, _):
1772 self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
1775 ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser2,cn=users," + self.base_dn)
1777 # ensure we cannot rename it twice
1779 ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn,
1780 "cn=ldaptestuser2,cn=users," + self.base_dn)
1782 except LdbError, (num, _):
1783 self.assertEquals(num, ERR_NO_SUCH_OBJECT)
1785 # ensure can now use that name
1786 ldb.add({"dn": "cn=ldaptestuser3,cn=users," + self.base_dn,
1787 "objectClass": "user",
1788 "cn": "LDAPtestUSER3"})
1790 # ensure we now cannot rename
1792 ldb.rename("cn=ldaptestuser2,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=users," + self.base_dn)
1794 except LdbError, (num, _):
1795 self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
1797 ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=configuration," + self.base_dn)
1799 except LdbError, (num, _):
1800 self.assertTrue(num in (71, 64))
1802 ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser5,cn=users," + self.base_dn)
1804 ldb.delete("cn=ldaptestuser5,cn=users," + self.base_dn)
1806 delete_force(ldb, "cn=ldaptestgroup2,cn=users," + self.base_dn)
1808 ldb.rename("cn=ldaptestgroup,cn=users," + self.base_dn, "cn=ldaptestgroup2,cn=users," + self.base_dn)
1810 print "Testing subtree renames"
1812 ldb.add({"dn": "cn=ldaptestcontainer," + self.base_dn,
1813 "objectClass": "container"})
1815 ldb.add({"dn": "CN=ldaptestuser4,CN=ldaptestcontainer," + self.base_dn,
1816 "objectClass": "user",
1817 "cn": "LDAPtestUSER4"})
1819 # Here we don't enforce these hard "description" constraints
1821 dn: cn=ldaptestcontainer,""" + self.base_dn + """
1823 replace: description
1829 dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
1832 member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """
1833 member: cn=ldaptestcomputer,cn=computers,""" + self.base_dn + """
1834 member: cn=ldaptestuser2,cn=users,""" + self.base_dn + """
1837 print "Testing ldb.rename of cn=ldaptestcontainer," + self.base_dn + " to cn=ldaptestcontainer2," + self.base_dn
1838 ldb.rename("CN=ldaptestcontainer," + self.base_dn, "CN=ldaptestcontainer2," + self.base_dn)
1840 print "Testing ldb.search for (&(cn=ldaptestuser4)(objectClass=user))"
1841 res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))")
1842 self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser4)(objectClass=user))")
1844 print "Testing subtree ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + self.base_dn
1846 res = ldb.search("cn=ldaptestcontainer," + self.base_dn,
1847 expression="(&(cn=ldaptestuser4)(objectClass=user))",
1848 scope=SCOPE_SUBTREE)
1850 except LdbError, (num, _):
1851 self.assertEquals(num, ERR_NO_SUCH_OBJECT)
1853 print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + self.base_dn
1855 res = ldb.search("cn=ldaptestcontainer," + self.base_dn,
1856 expression="(&(cn=ldaptestuser4)(objectClass=user))", scope=SCOPE_ONELEVEL)
1858 except LdbError, (num, _):
1859 self.assertEquals(num, ERR_NO_SUCH_OBJECT)
1861 print "Testing ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in renamed container"
1862 res = ldb.search("cn=ldaptestcontainer2," + self.base_dn, expression="(&(cn=ldaptestuser4)(objectClass=user))", scope=SCOPE_SUBTREE)
1863 self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser4)(objectClass=user)) under cn=ldaptestcontainer2," + self.base_dn)
1865 self.assertEquals(str(res[0].dn), ("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn))
1866 self.assertEquals(res[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
1870 print "Testing ldb.search for (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group)) to check subtree renames and linked attributes"
1871 res = ldb.search(self.base_dn, expression="(&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group))", scope=SCOPE_SUBTREE)
1872 self.assertEquals(len(res), 1, "Could not find (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group)), perhaps linked attributes are not consistant with subtree renames?")
1874 print "Testing ldb.rename (into itself) of cn=ldaptestcontainer2," + self.base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer2," + self.base_dn
1876 ldb.rename("cn=ldaptestcontainer2," + self.base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer2," + self.base_dn)
1878 except LdbError, (num, _):
1879 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1881 print "Testing ldb.rename (into non-existent container) of cn=ldaptestcontainer2," + self.base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer3," + self.base_dn
1883 ldb.rename("cn=ldaptestcontainer2," + self.base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer3," + self.base_dn)
1885 except LdbError, (num, _):
1886 self.assertTrue(num in (ERR_UNWILLING_TO_PERFORM, ERR_OTHER))
1888 print "Testing delete (should fail, not a leaf node) of renamed cn=ldaptestcontainer2," + self.base_dn
1890 ldb.delete("cn=ldaptestcontainer2," + self.base_dn)
1892 except LdbError, (num, _):
1893 self.assertEquals(num, ERR_NOT_ALLOWED_ON_NON_LEAF)
1895 print "Testing base ldb.search for CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn
1896 res = ldb.search(expression="(objectclass=*)", base=("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn), scope=SCOPE_BASE)
1897 self.assertEquals(len(res), 1)
1898 res = ldb.search(expression="(cn=ldaptestuser40)", base=("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn), scope=SCOPE_BASE)
1899 self.assertEquals(len(res), 0)
1901 print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in cn=ldaptestcontainer2," + self.base_dn
1902 res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))", base=("cn=ldaptestcontainer2," + self.base_dn), scope=SCOPE_ONELEVEL)
1903 # FIXME: self.assertEquals(len(res), 0)
1905 print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in cn=ldaptestcontainer2," + self.base_dn
1906 res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))", base=("cn=ldaptestcontainer2," + self.base_dn), scope=SCOPE_SUBTREE)
1907 # FIXME: self.assertEquals(len(res), 0)
1909 print "Testing delete of subtree renamed "+("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn)
1910 ldb.delete(("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn))
1911 print "Testing delete of renamed cn=ldaptestcontainer2," + self.base_dn
1912 ldb.delete("cn=ldaptestcontainer2," + self.base_dn)
1914 ldb.add({"dn": "cn=ldaptestutf8user èùéìòà,cn=users," + self.base_dn, "objectClass": "user"})
1916 ldb.add({"dn": "cn=ldaptestutf8user2 èùéìòà,cn=users," + self.base_dn, "objectClass": "user"})
1918 print "Testing ldb.search for (&(cn=ldaptestuser)(objectClass=user))"
1919 res = ldb.search(expression="(&(cn=ldaptestuser)(objectClass=user))")
1920 self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser)(objectClass=user))")
1922 self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn))
1923 self.assertEquals(str(res[0]["cn"]), "ldaptestuser")
1924 self.assertEquals(str(res[0]["name"]), "ldaptestuser")
1925 self.assertEquals(set(res[0]["objectClass"]), set(["top", "person", "organizationalPerson", "user"]))
1926 self.assertTrue("objectGUID" in res[0])
1927 self.assertTrue("whenCreated" in res[0])
1928 self.assertEquals(str(res[0]["objectCategory"]), ("CN=Person,CN=Schema,CN=Configuration," + self.base_dn))
1929 self.assertEquals(int(res[0]["sAMAccountType"][0]), ATYPE_NORMAL_ACCOUNT)
1930 self.assertEquals(int(res[0]["userAccountControl"][0]), UF_NORMAL_ACCOUNT | UF_PASSWD_NOTREQD | UF_ACCOUNTDISABLE)
1931 self.assertEquals(res[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
1932 self.assertEquals(len(res[0]["memberOf"]), 1)
1934 print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + self.base_dn + "))"
1935 res2 = ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + self.base_dn + "))")
1936 self.assertEquals(len(res2), 1, "Could not find (&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + self.base_dn + "))")
1938 self.assertEquals(res[0].dn, res2[0].dn)
1940 print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon))"
1941 res3 = ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=PerSon))")
1942 self.assertEquals(len(res3), 1, "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)): matched %d" % len(res3))
1944 self.assertEquals(res[0].dn, res3[0].dn)
1946 if gc_ldb is not None:
1947 print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog"
1948 res3gc = gc_ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=PerSon))")
1949 self.assertEquals(len(res3gc), 1)
1951 self.assertEquals(res[0].dn, res3gc[0].dn)
1953 print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon)) in with 'phantom root' control"
1955 if gc_ldb is not None:
1956 res3control = gc_ldb.search(self.base_dn, expression="(&(cn=ldaptestuser)(objectCategory=PerSon))", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:2"])
1957 self.assertEquals(len(res3control), 1, "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog")
1959 self.assertEquals(res[0].dn, res3control[0].dn)
1961 ldb.delete(res[0].dn)
1963 print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectClass=user))"
1964 res = ldb.search(expression="(&(cn=ldaptestcomputer)(objectClass=user))")
1965 self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser)(objectClass=user))")
1967 self.assertEquals(str(res[0].dn), ("CN=ldaptestcomputer,CN=Computers," + self.base_dn))
1968 self.assertEquals(str(res[0]["cn"]), "ldaptestcomputer")
1969 self.assertEquals(str(res[0]["name"]), "ldaptestcomputer")
1970 self.assertEquals(set(res[0]["objectClass"]), set(["top", "person", "organizationalPerson", "user", "computer"]))
1971 self.assertTrue("objectGUID" in res[0])
1972 self.assertTrue("whenCreated" in res[0])
1973 self.assertEquals(str(res[0]["objectCategory"]), ("CN=Computer,CN=Schema,CN=Configuration," + self.base_dn))
1974 self.assertEquals(int(res[0]["primaryGroupID"][0]), 513)
1975 self.assertEquals(int(res[0]["sAMAccountType"][0]), ATYPE_NORMAL_ACCOUNT)
1976 self.assertEquals(int(res[0]["userAccountControl"][0]), UF_NORMAL_ACCOUNT | UF_PASSWD_NOTREQD | UF_ACCOUNTDISABLE)
1977 self.assertEquals(res[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
1978 self.assertEquals(len(res[0]["memberOf"]), 1)
1980 print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + self.base_dn + "))"
1981 res2 = ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + self.base_dn + "))")
1982 self.assertEquals(len(res2), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + self.base_dn + "))")
1984 self.assertEquals(res[0].dn, res2[0].dn)
1986 if gc_ldb is not None:
1987 print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + self.base_dn + ")) in Global Catlog"
1988 res2gc = gc_ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + self.base_dn + "))")
1989 self.assertEquals(len(res2gc), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + self.base_dn + ")) in Global Catlog")
1991 self.assertEquals(res[0].dn, res2gc[0].dn)
1993 print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER))"
1994 res3 = ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=compuTER))")
1995 self.assertEquals(len(res3), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER))")
1997 self.assertEquals(res[0].dn, res3[0].dn)
1999 if gc_ldb is not None:
2000 print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog"
2001 res3gc = gc_ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=compuTER))")
2002 self.assertEquals(len(res3gc), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog")
2004 self.assertEquals(res[0].dn, res3gc[0].dn)
2006 print "Testing ldb.search for (&(cn=ldaptestcomp*r)(objectCategory=compuTER))"
2007 res4 = ldb.search(expression="(&(cn=ldaptestcomp*r)(objectCategory=compuTER))")
2008 self.assertEquals(len(res4), 1, "Could not find (&(cn=ldaptestcomp*r)(objectCategory=compuTER))")
2010 self.assertEquals(res[0].dn, res4[0].dn)
2012 print "Testing ldb.search for (&(cn=ldaptestcomput*)(objectCategory=compuTER))"
2013 res5 = ldb.search(expression="(&(cn=ldaptestcomput*)(objectCategory=compuTER))")
2014 self.assertEquals(len(res5), 1, "Could not find (&(cn=ldaptestcomput*)(objectCategory=compuTER))")
2016 self.assertEquals(res[0].dn, res5[0].dn)
2018 print "Testing ldb.search for (&(cn=*daptestcomputer)(objectCategory=compuTER))"
2019 res6 = ldb.search(expression="(&(cn=*daptestcomputer)(objectCategory=compuTER))")
2020 self.assertEquals(len(res6), 1, "Could not find (&(cn=*daptestcomputer)(objectCategory=compuTER))")
2022 self.assertEquals(res[0].dn, res6[0].dn)
2024 ldb.delete("<GUID=" + ldb.schema_format_value("objectGUID", res[0]["objectGUID"][0]) + ">")
2026 print "Testing ldb.search for (&(cn=ldaptest2computer)(objectClass=user))"
2027 res = ldb.search(expression="(&(cn=ldaptest2computer)(objectClass=user))")
2028 self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptest2computer)(objectClass=user))")
2030 self.assertEquals(str(res[0].dn), "CN=ldaptest2computer,CN=Computers," + self.base_dn)
2031 self.assertEquals(str(res[0]["cn"]), "ldaptest2computer")
2032 self.assertEquals(str(res[0]["name"]), "ldaptest2computer")
2033 self.assertEquals(list(res[0]["objectClass"]), ["top", "person", "organizationalPerson", "user", "computer"])
2034 self.assertTrue("objectGUID" in res[0])
2035 self.assertTrue("whenCreated" in res[0])
2036 self.assertEquals(res[0]["objectCategory"][0], "CN=Computer,CN=Schema,CN=Configuration," + self.base_dn)
2037 self.assertEquals(int(res[0]["sAMAccountType"][0]), ATYPE_WORKSTATION_TRUST)
2038 self.assertEquals(int(res[0]["userAccountControl"][0]), UF_WORKSTATION_TRUST_ACCOUNT)
2040 ldb.delete("<SID=" + ldb.schema_format_value("objectSID", res[0]["objectSID"][0]) + ">")
2042 attrs = ["cn", "name", "objectClass", "objectGUID", "objectSID", "whenCreated", "nTSecurityDescriptor", "memberOf", "allowedAttributes", "allowedAttributesEffective"]
2043 print "Testing ldb.search for (&(cn=ldaptestUSer2)(objectClass=user))"
2044 res_user = ldb.search(self.base_dn, expression="(&(cn=ldaptestUSer2)(objectClass=user))", scope=SCOPE_SUBTREE, attrs=attrs)
2045 self.assertEquals(len(res_user), 1, "Could not find (&(cn=ldaptestUSer2)(objectClass=user))")
2047 self.assertEquals(str(res_user[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
2048 self.assertEquals(str(res_user[0]["cn"]), "ldaptestuser2")
2049 self.assertEquals(str(res_user[0]["name"]), "ldaptestuser2")
2050 self.assertEquals(list(res_user[0]["objectClass"]), ["top", "person", "organizationalPerson", "user"])
2051 self.assertTrue("objectSid" in res_user[0])
2052 self.assertTrue("objectGUID" in res_user[0])
2053 self.assertTrue("whenCreated" in res_user[0])
2054 self.assertTrue("nTSecurityDescriptor" in res_user[0])
2055 self.assertTrue("allowedAttributes" in res_user[0])
2056 self.assertTrue("allowedAttributesEffective" in res_user[0])
2057 self.assertEquals(res_user[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
2059 ldaptestuser2_sid = res_user[0]["objectSid"][0]
2060 ldaptestuser2_guid = res_user[0]["objectGUID"][0]
2062 attrs = ["cn", "name", "objectClass", "objectGUID", "objectSID", "whenCreated", "nTSecurityDescriptor", "member", "allowedAttributes", "allowedAttributesEffective"]
2063 print "Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group))"
2064 res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs)
2065 self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))")
2067 self.assertEquals(str(res[0].dn), ("CN=ldaptestgroup2,CN=Users," + self.base_dn))
2068 self.assertEquals(str(res[0]["cn"]), "ldaptestgroup2")
2069 self.assertEquals(str(res[0]["name"]), "ldaptestgroup2")
2070 self.assertEquals(list(res[0]["objectClass"]), ["top", "group"])
2071 self.assertTrue("objectGUID" in res[0])
2072 self.assertTrue("objectSid" in res[0])
2073 self.assertTrue("whenCreated" in res[0])
2074 self.assertTrue("nTSecurityDescriptor" in res[0])
2075 self.assertTrue("allowedAttributes" in res[0])
2076 self.assertTrue("allowedAttributesEffective" in res[0])
2078 for m in res[0]["member"]:
2079 memberUP.append(m.upper())
2080 self.assertTrue(("CN=ldaptestuser2,CN=Users," + self.base_dn).upper() in memberUP)
2082 res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs, controls=["extended_dn:1:1"])
2083 self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))")
2085 print res[0]["member"]
2087 for m in res[0]["member"]:
2088 memberUP.append(m.upper())
2089 print ("<GUID=" + ldb.schema_format_value("objectGUID", ldaptestuser2_guid) + ">;<SID=" + ldb.schema_format_value("objectSid", ldaptestuser2_sid) + ">;CN=ldaptestuser2,CN=Users," + self.base_dn).upper()
2091 self.assertTrue(("<GUID=" + ldb.schema_format_value("objectGUID", ldaptestuser2_guid) + ">;<SID=" + ldb.schema_format_value("objectSid", ldaptestuser2_sid) + ">;CN=ldaptestuser2,CN=Users," + self.base_dn).upper() in memberUP)
2093 print "Quicktest for linked attributes"
2095 dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
2098 member: CN=ldaptestuser2,CN=Users,""" + self.base_dn + """
2099 member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
2103 dn: <GUID=""" + ldb.schema_format_value("objectGUID", res[0]["objectGUID"][0]) + """>
2106 member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
2110 dn: <SID=""" + ldb.schema_format_value("objectSid", res[0]["objectSid"][0]) + """>
2116 dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
2119 member: <GUID=""" + ldb.schema_format_value("objectGUID", res[0]["objectGUID"][0]) + """>
2120 member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
2124 dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
2130 dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
2133 member: <SID=""" + ldb.schema_format_value("objectSid", res_user[0]["objectSid"][0]) + """>
2134 member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
2138 dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
2141 member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
2144 res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs)
2145 self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))")
2147 self.assertEquals(str(res[0].dn), ("CN=ldaptestgroup2,CN=Users," + self.base_dn))
2148 self.assertEquals(res[0]["member"][0], ("CN=ldaptestuser2,CN=Users," + self.base_dn))
2149 self.assertEquals(len(res[0]["member"]), 1)
2151 ldb.delete(("CN=ldaptestuser2,CN=Users," + self.base_dn))
2155 attrs = ["cn", "name", "objectClass", "objectGUID", "whenCreated", "nTSecurityDescriptor", "member"]
2156 print "Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete"
2157 res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs)
2158 self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete")
2160 self.assertEquals(str(res[0].dn), ("CN=ldaptestgroup2,CN=Users," + self.base_dn))
2161 self.assertTrue("member" not in res[0])
2163 print "Testing ldb.search for (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))"
2164 # TODO UTF8 users don't seem to work fully anymore
2165 # res = ldb.search(expression="(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
2166 res = ldb.search(expression="(&(cn=ldaptestutf8user èùéìòà)(objectclass=user))")
2167 self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
2169 self.assertEquals(str(res[0].dn), ("CN=ldaptestutf8user èùéìòà,CN=Users," + self.base_dn))
2170 self.assertEquals(str(res[0]["cn"]), "ldaptestutf8user èùéìòà")
2171 self.assertEquals(str(res[0]["name"]), "ldaptestutf8user èùéìòà")
2172 self.assertEquals(list(res[0]["objectClass"]), ["top", "person", "organizationalPerson", "user"])
2173 self.assertTrue("objectGUID" in res[0])
2174 self.assertTrue("whenCreated" in res[0])
2176 ldb.delete(res[0].dn)
2178 print "Testing ldb.search for (&(cn=ldaptestutf8user2*)(objectClass=user))"
2179 res = ldb.search(expression="(&(cn=ldaptestutf8user2*)(objectClass=user))")
2180 self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestutf8user2*)(objectClass=user))")
2182 ldb.delete(res[0].dn)
2184 ldb.delete(("CN=ldaptestgroup2,CN=Users," + self.base_dn))
2186 print "Testing ldb.search for (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))"
2187 # TODO UTF8 users don't seem to work fully anymore
2188 # res = ldb.search(expression="(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
2189 # self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
2191 print "Testing that we can't get at the configuration DN from the main search base"
2192 res = ldb.search(self.base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"])
2193 self.assertEquals(len(res), 0)
2195 print "Testing that we can get at the configuration DN from the main search base on the LDAP port with the 'phantom root' search_options control"
2196 res = ldb.search(self.base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:2"])
2197 self.assertTrue(len(res) > 0)
2199 if gc_ldb is not None:
2200 print "Testing that we can get at the configuration DN from the main search base on the GC port with the search_options control == 0"
2202 res = gc_ldb.search(self.base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:0"])
2203 self.assertTrue(len(res) > 0)
2205 print "Testing that we do find configuration elements in the global catlog"
2206 res = gc_ldb.search(self.base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"])
2207 self.assertTrue(len(res) > 0)
2209 print "Testing that we do find configuration elements and user elements at the same time"
2210 res = gc_ldb.search(self.base_dn, expression="(|(objectClass=crossRef)(objectClass=person))", scope=SCOPE_SUBTREE, attrs=["cn"])
2211 self.assertTrue(len(res) > 0)
2213 print "Testing that we do find configuration elements in the global catlog, with the configuration basedn"
2214 res = gc_ldb.search(self.configuration_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"])
2215 self.assertTrue(len(res) > 0)
2217 print "Testing that we can get at the configuration DN on the main LDAP port"
2218 res = ldb.search(self.configuration_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"])
2219 self.assertTrue(len(res) > 0)
2221 print "Testing objectCategory canonacolisation"
2222 res = ldb.search(self.configuration_dn, expression="objectCategory=ntDsDSA", scope=SCOPE_SUBTREE, attrs=["cn"])
2223 self.assertTrue(len(res) > 0, "Didn't find any records with objectCategory=ntDsDSA")
2224 self.assertTrue(len(res) != 0)
2226 res = ldb.search(self.configuration_dn, expression="objectCategory=CN=ntDs-DSA," + self.schema_dn, scope=SCOPE_SUBTREE, attrs=["cn"])
2227 self.assertTrue(len(res) > 0, "Didn't find any records with objectCategory=CN=ntDs-DSA," + self.schema_dn)
2228 self.assertTrue(len(res) != 0)
2230 print "Testing objectClass attribute order on "+ self.base_dn
2231 res = ldb.search(expression="objectClass=domain", base=self.base_dn,
2232 scope=SCOPE_BASE, attrs=["objectClass"])
2233 self.assertEquals(len(res), 1)
2235 self.assertEquals(list(res[0]["objectClass"]), ["top", "domain", "domainDNS"])
2239 print "Testing ldb.search for objectCategory=person"
2240 res = ldb.search(self.base_dn, expression="objectCategory=person", scope=SCOPE_SUBTREE, attrs=["cn"])
2241 self.assertTrue(len(res) > 0)
2243 print "Testing ldb.search for objectCategory=person with domain scope control"
2244 res = ldb.search(self.base_dn, expression="objectCategory=person", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"])
2245 self.assertTrue(len(res) > 0)
2247 print "Testing ldb.search for objectCategory=user"
2248 res = ldb.search(self.base_dn, expression="objectCategory=user", scope=SCOPE_SUBTREE, attrs=["cn"])
2249 self.assertTrue(len(res) > 0)
2251 print "Testing ldb.search for objectCategory=user with domain scope control"
2252 res = ldb.search(self.base_dn, expression="objectCategory=user", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"])
2253 self.assertTrue(len(res) > 0)
2255 print "Testing ldb.search for objectCategory=group"
2256 res = ldb.search(self.base_dn, expression="objectCategory=group", scope=SCOPE_SUBTREE, attrs=["cn"])
2257 self.assertTrue(len(res) > 0)
2259 print "Testing ldb.search for objectCategory=group with domain scope control"
2260 res = ldb.search(self.base_dn, expression="objectCategory=group", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"])
2261 self.assertTrue(len(res) > 0)
2263 print "Testing creating a user with the posixAccount objectClass"
2264 self.ldb.add_ldif("""dn: cn=posixuser,CN=Users,%s
2267 objectClass: posixAccount
2269 objectClass: organizationalPerson
2275 homeDirectory: /home/posixuser
2276 loginShell: /bin/bash
2277 gecos: Posix User;;;
2278 description: A POSIX user"""% (self.base_dn))
2280 print "Testing removing the posixAccount objectClass from an existing user"
2281 self.ldb.modify_ldif("""dn: cn=posixuser,CN=Users,%s
2284 objectClass: posixAccount"""% (self.base_dn))
2286 print "Testing adding the posixAccount objectClass to an existing user"
2287 self.ldb.modify_ldif("""dn: cn=posixuser,CN=Users,%s
2290 objectClass: posixAccount"""% (self.base_dn))
2292 delete_force(self.ldb, "cn=posixuser,cn=users," + self.base_dn)
2293 delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
2294 delete_force(self.ldb, "cn=ldaptestuser2,cn=users," + self.base_dn)
2295 delete_force(self.ldb, "cn=ldaptestuser3,cn=users," + self.base_dn)
2296 delete_force(self.ldb, "cn=ldaptestuser4,cn=ldaptestcontainer," + self.base_dn)
2297 delete_force(self.ldb, "cn=ldaptestuser4,cn=ldaptestcontainer2," + self.base_dn)
2298 delete_force(self.ldb, "cn=ldaptestuser5,cn=users," + self.base_dn)
2299 delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
2300 delete_force(self.ldb, "cn=ldaptestgroup2,cn=users," + self.base_dn)
2301 delete_force(self.ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
2302 delete_force(self.ldb, "cn=ldaptest2computer,cn=computers," + self.base_dn)
2303 delete_force(self.ldb, "cn=ldaptestcomputer3,cn=computers," + self.base_dn)
2304 delete_force(self.ldb, "cn=ldaptestutf8user èùéìòà,cn=users," + self.base_dn)
2305 delete_force(self.ldb, "cn=ldaptestutf8user2 èùéìòà,cn=users," + self.base_dn)
2306 delete_force(self.ldb, "cn=ldaptestcontainer," + self.base_dn)
2307 delete_force(self.ldb, "cn=ldaptestcontainer2," + self.base_dn)
2309 def test_security_descriptor_add(self):
2310 """ Testing ldb.add_ldif() for nTSecurityDescriptor """
2311 user_name = "testdescriptoruser1"
2312 user_dn = "CN=%s,CN=Users,%s" % (user_name, self.base_dn)
2314 # Test an empty security descriptor (naturally this shouldn't work)
2316 delete_force(self.ldb, user_dn)
2318 self.ldb.add({ "dn": user_dn,
2319 "objectClass": "user",
2320 "sAMAccountName": user_name,
2321 "nTSecurityDescriptor": [] })
2323 except LdbError, (num, _):
2324 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
2326 delete_force(self.ldb, user_dn)
2328 # Test add_ldif() with SDDL security descriptor input
2331 sddl = "O:DUG:DUD:PAI(A;;RPWP;;;AU)S:PAI"
2332 self.ldb.add_ldif("""
2333 dn: """ + user_dn + """
2335 sAMAccountName: """ + user_name + """
2336 nTSecurityDescriptor: """ + sddl)
2337 res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2338 desc = res[0]["nTSecurityDescriptor"][0]
2339 desc = ndr_unpack( security.descriptor, desc )
2340 desc_sddl = desc.as_sddl( self.domain_sid )
2341 self.assertEqual(desc_sddl, sddl)
2343 delete_force(self.ldb, user_dn)
2345 # Test add_ldif() with BASE64 security descriptor
2348 sddl = "O:DUG:DUD:PAI(A;;RPWP;;;AU)S:PAI"
2349 desc = security.descriptor.from_sddl(sddl, self.domain_sid)
2350 desc_binary = ndr_pack(desc)
2351 desc_base64 = base64.b64encode(desc_binary)
2352 self.ldb.add_ldif("""
2353 dn: """ + user_dn + """
2355 sAMAccountName: """ + user_name + """
2356 nTSecurityDescriptor:: """ + desc_base64)
2357 res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2358 desc = res[0]["nTSecurityDescriptor"][0]
2359 desc = ndr_unpack(security.descriptor, desc)
2360 desc_sddl = desc.as_sddl(self.domain_sid)
2361 self.assertEqual(desc_sddl, sddl)
2363 delete_force(self.ldb, user_dn)
2365 def test_security_descriptor_add_neg(self):
2366 """Test add_ldif() with BASE64 security descriptor input using WRONG domain SID
2369 user_name = "testdescriptoruser1"
2370 user_dn = "CN=%s,CN=Users,%s" % (user_name, self.base_dn)
2371 delete_force(self.ldb, user_dn)
2373 sddl = "O:DUG:DUD:PAI(A;;RPWP;;;AU)S:PAI"
2374 desc = security.descriptor.from_sddl(sddl, security.dom_sid('S-1-5-21'))
2375 desc_base64 = base64.b64encode( ndr_pack(desc) )
2376 self.ldb.add_ldif("""
2377 dn: """ + user_dn + """
2379 sAMAccountName: """ + user_name + """
2380 nTSecurityDescriptor:: """ + desc_base64)
2381 res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2382 self.assertTrue("nTSecurityDescriptor" in res[0])
2384 delete_force(self.ldb, user_dn)
2386 def test_security_descriptor_modify(self):
2387 """ Testing ldb.modify_ldif() for nTSecurityDescriptor """
2388 user_name = "testdescriptoruser2"
2389 user_dn = "CN=%s,CN=Users,%s" % (user_name, self.base_dn)
2391 # Test an empty security descriptor (naturally this shouldn't work)
2393 delete_force(self.ldb, user_dn)
2394 self.ldb.add({ "dn": user_dn,
2395 "objectClass": "user",
2396 "sAMAccountName": user_name })
2399 m.dn = Dn(ldb, user_dn)
2400 m["nTSecurityDescriptor"] = MessageElement([], FLAG_MOD_ADD,
2401 "nTSecurityDescriptor")
2405 except LdbError, (num, _):
2406 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
2409 m.dn = Dn(ldb, user_dn)
2410 m["nTSecurityDescriptor"] = MessageElement([], FLAG_MOD_REPLACE,
2411 "nTSecurityDescriptor")
2415 except LdbError, (num, _):
2416 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
2419 m.dn = Dn(ldb, user_dn)
2420 m["nTSecurityDescriptor"] = MessageElement([], FLAG_MOD_DELETE,
2421 "nTSecurityDescriptor")
2425 except LdbError, (num, _):
2426 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
2428 delete_force(self.ldb, user_dn)
2430 # Test modify_ldif() with SDDL security descriptor input
2431 # Add ACE to the original descriptor test
2434 self.ldb.add_ldif("""
2435 dn: """ + user_dn + """
2437 sAMAccountName: """ + user_name)
2439 res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2440 desc = res[0]["nTSecurityDescriptor"][0]
2441 desc = ndr_unpack(security.descriptor, desc)
2442 desc_sddl = desc.as_sddl(self.domain_sid)
2443 sddl = desc_sddl[:desc_sddl.find("(")] + "(A;;RPWP;;;AU)" + desc_sddl[desc_sddl.find("("):]
2445 dn: """ + user_dn + """
2447 replace: nTSecurityDescriptor
2448 nTSecurityDescriptor: """ + sddl
2449 self.ldb.modify_ldif(mod)
2450 # Read modified descriptor
2451 res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2452 desc = res[0]["nTSecurityDescriptor"][0]
2453 desc = ndr_unpack(security.descriptor, desc)
2454 desc_sddl = desc.as_sddl(self.domain_sid)
2455 self.assertEqual(desc_sddl, sddl)
2457 delete_force(self.ldb, user_dn)
2459 # Test modify_ldif() with SDDL security descriptor input
2460 # New desctiptor test
2463 self.ldb.add_ldif("""
2464 dn: """ + user_dn + """
2466 sAMAccountName: """ + user_name)
2468 sddl = "O:DUG:DUD:PAI(A;;RPWP;;;AU)S:PAI"
2470 dn: """ + user_dn + """
2472 replace: nTSecurityDescriptor
2473 nTSecurityDescriptor: """ + sddl
2474 self.ldb.modify_ldif(mod)
2475 # Read modified descriptor
2476 res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2477 desc = res[0]["nTSecurityDescriptor"][0]
2478 desc = ndr_unpack(security.descriptor, desc)
2479 desc_sddl = desc.as_sddl(self.domain_sid)
2480 self.assertEqual(desc_sddl, sddl)
2482 delete_force(self.ldb, user_dn)
2484 # Test modify_ldif() with BASE64 security descriptor input
2485 # Add ACE to the original descriptor test
2488 self.ldb.add_ldif("""
2489 dn: """ + user_dn + """
2491 sAMAccountName: """ + user_name)
2493 res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2494 desc = res[0]["nTSecurityDescriptor"][0]
2495 desc = ndr_unpack(security.descriptor, desc)
2496 desc_sddl = desc.as_sddl(self.domain_sid)
2497 sddl = desc_sddl[:desc_sddl.find("(")] + "(A;;RPWP;;;AU)" + desc_sddl[desc_sddl.find("("):]
2498 desc = security.descriptor.from_sddl(sddl, self.domain_sid)
2499 desc_base64 = base64.b64encode(ndr_pack(desc))
2501 dn: """ + user_dn + """
2503 replace: nTSecurityDescriptor
2504 nTSecurityDescriptor:: """ + desc_base64
2505 self.ldb.modify_ldif(mod)
2506 # Read modified descriptor
2507 res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2508 desc = res[0]["nTSecurityDescriptor"][0]
2509 desc = ndr_unpack(security.descriptor, desc)
2510 desc_sddl = desc.as_sddl(self.domain_sid)
2511 self.assertEqual(desc_sddl, sddl)
2513 delete_force(self.ldb, user_dn)
2515 # Test modify_ldif() with BASE64 security descriptor input
2516 # New descriptor test
2519 delete_force(self.ldb, user_dn)
2520 self.ldb.add_ldif("""
2521 dn: """ + user_dn + """
2523 sAMAccountName: """ + user_name)
2525 sddl = "O:DUG:DUD:PAI(A;;RPWP;;;AU)S:PAI"
2526 desc = security.descriptor.from_sddl(sddl, self.domain_sid)
2527 desc_base64 = base64.b64encode(ndr_pack(desc))
2529 dn: """ + user_dn + """
2531 replace: nTSecurityDescriptor
2532 nTSecurityDescriptor:: """ + desc_base64
2533 self.ldb.modify_ldif(mod)
2534 # Read modified descriptor
2535 res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2536 desc = res[0]["nTSecurityDescriptor"][0]
2537 desc = ndr_unpack(security.descriptor, desc)
2538 desc_sddl = desc.as_sddl(self.domain_sid)
2539 self.assertEqual(desc_sddl, sddl)
2541 delete_force(self.ldb, user_dn)
2543 def test_dsheuristics(self):
2544 """Tests the 'dSHeuristics' attribute"""
2545 print "Tests the 'dSHeuristics' attribute"""
2547 # Get the current value to restore it later
2548 dsheuristics = self.ldb.get_dsheuristics()
2549 # Should not be longer than 18 chars?
2551 self.ldb.set_dsheuristics("123ABC-+!1asdfg@#^12")
2552 except LdbError, (num, _):
2553 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
2554 # If it is >= 10 chars, tenthChar should be 1
2556 self.ldb.set_dsheuristics("00020000000002")
2557 except LdbError, (num, _):
2558 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
2559 # apart from the above, all char values are accepted
2560 self.ldb.set_dsheuristics("123ABC-+!1asdfg@#^")
2561 self.assertEquals(self.ldb.get_dsheuristics(), "123ABC-+!1asdfg@#^")
2563 self.ldb.set_dsheuristics(dsheuristics)
2566 class BaseDnTests(unittest.TestCase):
2569 super(BaseDnTests, self).setUp()
2572 def test_rootdse_attrs(self):
2573 """Testing for all rootDSE attributes"""
2574 res = self.ldb.search(scope=SCOPE_BASE, attrs=[])
2575 self.assertEquals(len(res), 1)
2577 def test_highestcommittedusn(self):
2578 """Testing for highestCommittedUSN"""
2579 res = self.ldb.search("", scope=SCOPE_BASE, attrs=["highestCommittedUSN"])
2580 self.assertEquals(len(res), 1)
2581 self.assertTrue(int(res[0]["highestCommittedUSN"][0]) != 0)
2583 def test_netlogon(self):
2584 """Testing for netlogon via LDAP"""
2585 res = self.ldb.search("", scope=SCOPE_BASE, attrs=["netlogon"])
2586 self.assertEquals(len(res), 0)
2588 def test_netlogon_highestcommitted_usn(self):
2589 """Testing for netlogon and highestCommittedUSN via LDAP"""
2590 res = self.ldb.search("", scope=SCOPE_BASE,
2591 attrs=["netlogon", "highestCommittedUSN"])
2592 self.assertEquals(len(res), 0)
2594 def test_namingContexts(self):
2595 """Testing for namingContexts in rootDSE"""
2596 res = self.ldb.search("", scope=SCOPE_BASE,
2597 attrs=["namingContexts", "defaultNamingContext", "schemaNamingContext", "configurationNamingContext"])
2598 self.assertEquals(len(res), 1)
2601 for nc in res[0]["namingContexts"]:
2602 self.assertTrue(nc not in ncs)
2605 self.assertTrue(res[0]["defaultNamingContext"][0] in ncs)
2606 self.assertTrue(res[0]["configurationNamingContext"][0] in ncs)
2607 self.assertTrue(res[0]["schemaNamingContext"][0] in ncs)
2609 def test_serverPath(self):
2610 """Testing the server paths in rootDSE"""
2611 res = self.ldb.search("", scope=SCOPE_BASE,
2612 attrs=["dsServiceName", "serverName"])
2613 self.assertEquals(len(res), 1)
2615 self.assertTrue("CN=Servers" in res[0]["dsServiceName"][0])
2616 self.assertTrue("CN=Sites" in res[0]["dsServiceName"][0])
2617 self.assertTrue("CN=NTDS Settings" in res[0]["dsServiceName"][0])
2618 self.assertTrue("CN=Servers" in res[0]["serverName"][0])
2619 self.assertTrue("CN=Sites" in res[0]["serverName"][0])
2620 self.assertFalse("CN=NTDS Settings" in res[0]["serverName"][0])
2622 def test_dnsHostname(self):
2623 """Testing the DNS hostname in rootDSE"""
2624 res = self.ldb.search("", scope=SCOPE_BASE,
2625 attrs=["dnsHostName", "serverName"])
2626 self.assertEquals(len(res), 1)
2628 res2 = self.ldb.search(res[0]["serverName"][0], scope=SCOPE_BASE,
2629 attrs=["dNSHostName"])
2630 self.assertEquals(len(res2), 1)
2632 self.assertEquals(res[0]["dnsHostName"][0], res2[0]["dNSHostName"][0])
2634 def test_ldapServiceName(self):
2635 """Testing the ldap service name in rootDSE"""
2636 res = self.ldb.search("", scope=SCOPE_BASE,
2637 attrs=["ldapServiceName", "dNSHostName"])
2638 self.assertEquals(len(res), 1)
2640 (hostname, _, dns_domainname) = res[0]["dNSHostName"][0].partition(".")
2641 self.assertTrue(":%s$@%s" % (hostname, dns_domainname.upper())
2642 in res[0]["ldapServiceName"][0])
2644 if not "://" in host:
2645 if os.path.isfile(host):
2646 host = "tdb://%s" % host
2648 host = "ldap://%s" % host
2650 ldb = SamDB(host, credentials=creds, session_info=system_session(), lp=lp)
2651 if not "tdb://" in host:
2652 gc_ldb = Ldb("%s:3268" % host, credentials=creds,
2653 session_info=system_session(), lp=lp)
2657 runner = SubunitTestRunner()
2659 if not runner.run(unittest.makeSuite(BaseDnTests)).wasSuccessful():
2661 if not runner.run(unittest.makeSuite(BasicTests)).wasSuccessful():