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("subunit", "subunit/python")
14 samba.ensure_external_module("testtools", "testtools")
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
24 from ldb import ERR_OBJECT_CLASS_VIOLATION, ERR_NOT_ALLOWED_ON_RDN
25 from ldb import ERR_NAMING_VIOLATION, ERR_CONSTRAINT_VIOLATION
26 from ldb import ERR_UNDEFINED_ATTRIBUTE_TYPE
27 from ldb import Message, MessageElement, Dn
28 from ldb import FLAG_MOD_ADD, FLAG_MOD_REPLACE, FLAG_MOD_DELETE
30 from samba.dsdb import (UF_NORMAL_ACCOUNT, UF_INTERDOMAIN_TRUST_ACCOUNT,
31 UF_WORKSTATION_TRUST_ACCOUNT, UF_SERVER_TRUST_ACCOUNT,
32 UF_PASSWD_NOTREQD, UF_ACCOUNTDISABLE, ATYPE_NORMAL_ACCOUNT,
33 ATYPE_WORKSTATION_TRUST, SYSTEM_FLAG_DOMAIN_DISALLOW_MOVE)
34 from samba.dcerpc.security import (DOMAIN_RID_USERS, DOMAIN_RID_DOMAIN_MEMBERS,
37 from subunit.run import SubunitTestRunner
40 from samba.ndr import ndr_pack, ndr_unpack
41 from samba.dcerpc import security
43 parser = optparse.OptionParser("ldap [options] <host>")
44 sambaopts = options.SambaOptions(parser)
45 parser.add_option_group(sambaopts)
46 parser.add_option_group(options.VersionOptions(parser))
47 # use command line creds if available
48 credopts = options.CredentialsOptions(parser)
49 parser.add_option_group(credopts)
50 opts, args = parser.parse_args()
58 lp = sambaopts.get_loadparm()
59 creds = credopts.get_credentials(lp)
61 class BasicTests(unittest.TestCase):
63 def delete_force(self, ldb, dn):
66 except LdbError, (num, _):
67 self.assertEquals(num, ERR_NO_SUCH_OBJECT)
69 def find_basedn(self, ldb):
70 res = ldb.search(base="", expression="", scope=SCOPE_BASE,
71 attrs=["defaultNamingContext"])
72 self.assertEquals(len(res), 1)
73 return res[0]["defaultNamingContext"][0]
75 def find_configurationdn(self, ldb):
76 res = ldb.search(base="", expression="", scope=SCOPE_BASE, attrs=["configurationNamingContext"])
77 self.assertEquals(len(res), 1)
78 return res[0]["configurationNamingContext"][0]
80 def find_schemadn(self, ldb):
81 res = ldb.search(base="", expression="", scope=SCOPE_BASE, attrs=["schemaNamingContext"])
82 self.assertEquals(len(res), 1)
83 return res[0]["schemaNamingContext"][0]
85 def find_domain_sid(self):
86 res = self.ldb.search(base=self.base_dn, expression="(objectClass=*)", scope=SCOPE_BASE)
87 return ndr_unpack( security.dom_sid,res[0]["objectSid"][0])
90 super(BasicTests, self).setUp()
93 self.base_dn = self.find_basedn(ldb)
94 self.configuration_dn = self.find_configurationdn(ldb)
95 self.schema_dn = self.find_schemadn(ldb)
96 self.domain_sid = self.find_domain_sid()
98 print "baseDN: %s\n" % self.base_dn
100 self.delete_force(self.ldb, "cn=posixuser,cn=users," + self.base_dn)
101 self.delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
102 self.delete_force(self.ldb, "cn=ldaptestuser2,cn=users," + self.base_dn)
103 self.delete_force(self.ldb, "cn=ldaptestuser3,cn=users," + self.base_dn)
104 self.delete_force(self.ldb, "cn=ldaptestuser4,cn=ldaptestcontainer," + self.base_dn)
105 self.delete_force(self.ldb, "cn=ldaptestuser4,cn=ldaptestcontainer2," + self.base_dn)
106 self.delete_force(self.ldb, "cn=ldaptestuser5,cn=users," + self.base_dn)
107 self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
108 self.delete_force(self.ldb, "cn=ldaptestgroup2,cn=users," + self.base_dn)
109 self.delete_force(self.ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
110 self.delete_force(self.ldb, "cn=ldaptest2computer,cn=computers," + self.base_dn)
111 self.delete_force(self.ldb, "cn=ldaptestcomputer3,cn=computers," + self.base_dn)
112 self.delete_force(self.ldb, "cn=ldaptestutf8user èùéìòà,cn=users," + self.base_dn)
113 self.delete_force(self.ldb, "cn=ldaptestutf8user2 èùéìòà,cn=users," + self.base_dn)
114 self.delete_force(self.ldb, "cn=entry1,cn=ldaptestcontainer," + self.base_dn)
115 self.delete_force(self.ldb, "cn=entry2,cn=ldaptestcontainer," + self.base_dn)
116 self.delete_force(self.ldb, "cn=ldaptestcontainer," + self.base_dn)
117 self.delete_force(self.ldb, "cn=ldaptestcontainer2," + self.base_dn)
118 self.delete_force(self.ldb, "cn=parentguidtest,cn=users," + self.base_dn)
119 self.delete_force(self.ldb, "cn=parentguidtest,cn=testotherusers," + self.base_dn)
120 self.delete_force(self.ldb, "cn=testotherusers," + self.base_dn)
121 self.delete_force(self.ldb, "cn=ldaptestobject," + self.base_dn)
122 self.delete_force(self.ldb, "description=xyz,cn=users," + self.base_dn)
123 self.delete_force(self.ldb, "ou=testou,cn=users," + self.base_dn)
124 self.delete_force(self.ldb, "cn=testsecret,cn=system," + self.base_dn)
126 def test_objectclasses(self):
127 """Test objectClass behaviour"""
128 print "Test objectClass behaviour"""
130 # We cannot create LSA-specific objects (oc "secret" or "trustedDomain")
133 "dn": "cn=testsecret,cn=system," + self.base_dn,
134 "objectClass": "secret" })
136 except LdbError, (num, _):
137 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
139 # Invalid objectclass specified
142 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
143 "objectClass": "X" })
145 except LdbError, (num, _):
146 self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
148 # Invalid objectCategory specified
151 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
152 "objectClass": "person",
153 "objectCategory": self.base_dn })
155 except LdbError, (num, _):
156 self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
158 # Multi-valued "systemFlags"
161 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
162 "objectClass": "person",
163 "systemFlags": ["0", str(SYSTEM_FLAG_DOMAIN_DISALLOW_MOVE)] })
165 except LdbError, (num, _):
166 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
168 # We cannot instanciate from an abstract objectclass
171 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
172 "objectClass": "connectionPoint" })
174 except LdbError, (num, _):
175 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
178 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
179 "objectClass": "person" })
181 # We can remove derivation classes of the structural objectclass
182 # but they're going to be readded afterwards
184 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
185 m["objectClass"] = MessageElement("top", FLAG_MOD_DELETE,
189 res = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
190 scope=SCOPE_BASE, attrs=["objectClass"])
191 self.assertTrue(len(res) == 1)
192 self.assertTrue("top" in res[0]["objectClass"])
194 # The top-most structural class cannot be deleted since there are
195 # attributes of it in use
197 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
198 m["objectClass"] = MessageElement("person", FLAG_MOD_DELETE,
203 except LdbError, (num, _):
204 self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
206 # We cannot delete classes which weren't specified
208 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
209 m["objectClass"] = MessageElement("computer", FLAG_MOD_DELETE,
214 except LdbError, (num, _):
215 self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
217 # An invalid class cannot be added
219 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
220 m["objectClass"] = MessageElement("X", FLAG_MOD_ADD,
225 except LdbError, (num, _):
226 self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
228 # The top-most structural class cannot be changed by adding another
231 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
232 m["objectClass"] = MessageElement("user", FLAG_MOD_ADD,
237 except LdbError, (num, _):
238 self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
240 # An already specified objectclass cannot be added another time
242 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
243 m["objectClass"] = MessageElement("person", FLAG_MOD_ADD,
248 except LdbError, (num, _):
249 self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
251 # Auxiliary classes can always be added
253 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
254 m["objectClass"] = MessageElement("bootableDevice", FLAG_MOD_ADD,
258 # It's only possible to replace with the same objectclass combination.
259 # So the replace action on "objectClass" attributes is really useless.
261 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
262 m["objectClass"] = MessageElement(["top", "person", "bootableDevice"],
263 FLAG_MOD_REPLACE, "objectClass")
267 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
268 m["objectClass"] = MessageElement(["person", "bootableDevice"],
269 FLAG_MOD_REPLACE, "objectClass")
273 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
274 m["objectClass"] = MessageElement(["top", "person", "bootableDevice",
275 "connectionPoint"], FLAG_MOD_REPLACE, "objectClass")
279 except LdbError, (num, _):
280 self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
283 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
284 m["objectClass"] = MessageElement(["top", "computer"], FLAG_MOD_REPLACE,
289 except LdbError, (num, _):
290 self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
292 # Classes can be removed unless attributes of them are used.
294 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
295 m["objectClass"] = MessageElement("bootableDevice", FLAG_MOD_DELETE,
299 res = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
300 scope=SCOPE_BASE, attrs=["objectClass"])
301 self.assertTrue(len(res) == 1)
302 self.assertFalse("bootableDevice" in res[0]["objectClass"])
305 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
306 m["objectClass"] = MessageElement("bootableDevice", FLAG_MOD_ADD,
310 # Add an attribute specific to the "bootableDevice" class
312 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
313 m["bootParameter"] = MessageElement("test", FLAG_MOD_ADD,
317 # Classes can be removed unless attributes of them are used. Now there
318 # exist such attributes on the entry.
320 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
321 m["objectClass"] = MessageElement("bootableDevice", FLAG_MOD_DELETE,
326 except LdbError, (num, _):
327 self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
329 # Remove the previously specified attribute
331 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
332 m["bootParameter"] = MessageElement("test", FLAG_MOD_DELETE,
336 # Classes can be removed unless attributes of them are used.
338 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
339 m["objectClass"] = MessageElement("bootableDevice", FLAG_MOD_DELETE,
343 self.delete_force(self.ldb, "cn=ldaptestuser2,cn=users," + self.base_dn)
345 def test_system_only(self):
346 """Test systemOnly objects"""
347 print "Test systemOnly objects"""
351 "dn": "cn=ldaptestobject," + self.base_dn,
352 "objectclass": "configuration"})
354 except LdbError, (num, _):
355 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
357 self.delete_force(self.ldb, "cn=ldaptestobject," + self.base_dn)
358 self.delete_force(self.ldb, "cn=testsecret,cn=system," + self.base_dn)
360 def test_invalid_parent(self):
361 """Test adding an object with invalid parent"""
362 print "Test adding an object with invalid parent"""
366 "dn": "cn=ldaptestgroup,cn=thisdoesnotexist123,"
368 "objectclass": "group"})
370 except LdbError, (num, _):
371 self.assertEquals(num, ERR_NO_SUCH_OBJECT)
373 self.delete_force(self.ldb, "cn=ldaptestgroup,cn=thisdoesnotexist123,"
378 "dn": "ou=testou,cn=users," + self.base_dn,
379 "objectclass": "organizationalUnit"})
381 except LdbError, (num, _):
382 self.assertEquals(num, ERR_NAMING_VIOLATION)
384 self.delete_force(self.ldb, "ou=testou,cn=users," + self.base_dn)
386 def test_invalid_attribute(self):
387 """Test invalid attributes on schema/objectclasses"""
388 print "Test invalid attributes on schema/objectclasses"""
390 # attributes not in schema test
396 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
397 "objectclass": "group",
398 "thisdoesnotexist": "x"})
400 except LdbError, (num, _):
401 self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
404 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
405 "objectclass": "group"})
410 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
411 m["thisdoesnotexist"] = MessageElement("x", FLAG_MOD_REPLACE,
416 except LdbError, (num, _):
417 self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
419 self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
421 # attributes not in objectclasses and mandatory attributes missing test
422 # Use here a non-SAM entry since it doesn't have special triggers
423 # associated which have an impact on the error results.
427 # mandatory attribute missing
430 "dn": "cn=ldaptestobject," + self.base_dn,
431 "objectclass": "ipProtocol"})
433 except LdbError, (num, _):
434 self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
436 # inadequate but schema-valid attribute specified
439 "dn": "cn=ldaptestobject," + self.base_dn,
440 "objectclass": "ipProtocol",
441 "ipProtocolNumber": "1",
444 except LdbError, (num, _):
445 self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
448 "dn": "cn=ldaptestobject," + self.base_dn,
449 "objectclass": "ipProtocol",
450 "ipProtocolNumber": "1"})
454 # inadequate but schema-valid attribute add trial
456 m.dn = Dn(ldb, "cn=ldaptestobject," + self.base_dn)
457 m["uid"] = MessageElement("0", FLAG_MOD_ADD, "uid")
461 except LdbError, (num, _):
462 self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
464 # mandatory attribute delete trial
466 m.dn = Dn(ldb, "cn=ldaptestobject," + self.base_dn)
467 m["ipProtocolNumber"] = MessageElement([], FLAG_MOD_DELETE,
472 except LdbError, (num, _):
473 self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
475 # mandatory attribute delete trial
477 m.dn = Dn(ldb, "cn=ldaptestobject," + self.base_dn)
478 m["ipProtocolNumber"] = MessageElement([], FLAG_MOD_REPLACE,
483 except LdbError, (num, _):
484 self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
486 self.delete_force(self.ldb, "cn=ldaptestobject," + self.base_dn)
488 def test_single_valued_attributes(self):
489 """Test single-valued attributes"""
490 print "Test single-valued attributes"""
494 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
495 "objectclass": "group",
496 "sAMAccountName": ["nam1", "nam2"]})
498 except LdbError, (num, _):
499 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
502 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
503 "objectclass": "group"})
506 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
507 m["sAMAccountName"] = MessageElement(["nam1","nam2"], FLAG_MOD_REPLACE,
512 except LdbError, (num, _):
513 self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
516 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
517 m["sAMAccountName"] = MessageElement("testgroupXX", FLAG_MOD_REPLACE,
522 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
523 m["sAMAccountName"] = MessageElement("testgroupXX2", FLAG_MOD_ADD,
528 except LdbError, (num, _):
529 self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
531 self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
533 def test_multi_valued_attributes(self):
534 """Test multi-valued attributes"""
535 print "Test multi-valued attributes"""
537 # TODO: In this test I added some special tests where I got very unusual
538 # results back from a real AD. s4 doesn't match them and I've no idea how to
539 # implement those error cases (maybe there exists a special trigger for
540 # "description" attributes which handle them)
543 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
544 "description": "desc2",
545 "objectclass": "group",
546 "description": "desc1"})
548 self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
551 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
552 "objectclass": "group",
553 "description": ["desc1", "desc2"]})
556 # m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
557 # m["description"] = MessageElement(["desc1","desc2"], FLAG_MOD_REPLACE,
562 # except LdbError, (num, _):
563 # self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
566 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
567 m["description"] = MessageElement("desc1", FLAG_MOD_REPLACE,
572 # m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
573 # m["description"] = MessageElement("desc3", FLAG_MOD_ADD,
578 # except LdbError, (num, _):
579 # self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
582 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
583 m["description"] = MessageElement(["desc1","desc2"], FLAG_MOD_DELETE,
588 except LdbError, (num, _):
589 self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
592 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
593 m["description"] = MessageElement("desc1", FLAG_MOD_DELETE,
598 # m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
599 # m["description"] = MessageElement(["desc1","desc2"], FLAG_MOD_REPLACE,
604 # except LdbError, (num, _):
605 # self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
608 # m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
609 # m["description"] = MessageElement(["desc3", "desc4"], FLAG_MOD_ADD,
614 # except LdbError, (num, _):
615 # self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
618 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
619 m["description"] = MessageElement("desc3", FLAG_MOD_ADD,
623 self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
625 def test_empty_messages(self):
626 """Test empty messages"""
627 print "Test empty messages"""
630 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
635 except LdbError, (num, _):
636 self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
641 except LdbError, (num, _):
642 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
644 self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
646 def test_empty_attributes(self):
647 """Test empty attributes"""
648 print "Test empty attributes"""
651 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
652 m["objectClass"] = MessageElement("group", FLAG_MOD_ADD, "objectClass")
653 m["description"] = MessageElement([], FLAG_MOD_ADD, "description")
658 except LdbError, (num, _):
659 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
662 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
663 "objectclass": "group"})
666 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
667 m["description"] = MessageElement([], FLAG_MOD_ADD, "description")
672 except LdbError, (num, _):
673 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
676 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
677 m["description"] = MessageElement([], FLAG_MOD_REPLACE, "description")
681 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
682 m["description"] = MessageElement([], FLAG_MOD_DELETE, "description")
686 except LdbError, (num, _):
687 self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
689 self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
691 def test_instanceType(self):
692 """Tests the 'instanceType' attribute"""
693 print "Tests the 'instanceType' attribute"""
695 # The instance type is single-valued
698 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
699 "objectclass": "group",
700 "instanceType": ["0", "1"]})
702 except LdbError, (num, _):
703 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
705 # The head NC flag cannot be set without the write flag
708 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
709 "objectclass": "group",
710 "instanceType": "1" })
712 except LdbError, (num, _):
713 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
715 # We cannot manipulate NCs without the head NC flag
718 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
719 "objectclass": "group",
720 "instanceType": "32" })
722 except LdbError, (num, _):
723 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
726 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
727 "objectclass": "group"})
730 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
731 m["instanceType"] = MessageElement("0", FLAG_MOD_REPLACE,
736 except LdbError, (num, _):
737 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
740 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
741 m["instanceType"] = MessageElement([], FLAG_MOD_REPLACE,
746 except LdbError, (num, _):
747 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
750 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
751 m["instanceType"] = MessageElement([], FLAG_MOD_DELETE, "instanceType")
755 except LdbError, (num, _):
756 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
758 self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
760 def test_distinguished_name(self):
761 """Tests the 'distinguishedName' attribute"""
762 print "Tests the 'distinguishedName' attribute"""
764 # a wrong "distinguishedName" attribute is obviously tolerated
766 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
767 "objectclass": "group",
768 "distinguishedName": "cn=ldaptest,cn=users," + self.base_dn})
770 # proof if the DN has been set correctly
771 res = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
772 scope=SCOPE_BASE, attrs=["distinguishedName"])
773 self.assertTrue(len(res) == 1)
774 self.assertTrue("distinguishedName" in res[0])
775 self.assertTrue(Dn(ldb, res[0]["distinguishedName"][0])
776 == Dn(ldb, "cn=ldaptestgroup, cn=users," + self.base_dn))
779 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
780 m["distinguishedName"] = MessageElement(
781 "cn=ldaptestuser,cn=users," + self.base_dn, FLAG_MOD_ADD,
787 except LdbError, (num, _):
788 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
791 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
792 m["distinguishedName"] = MessageElement(
793 "cn=ldaptestuser,cn=users," + self.base_dn, FLAG_MOD_REPLACE,
799 except LdbError, (num, _):
800 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
803 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
804 m["distinguishedName"] = MessageElement(
805 "cn=ldaptestuser,cn=users," + self.base_dn, FLAG_MOD_DELETE,
811 except LdbError, (num, _):
812 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
814 self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
816 def test_rdn_name(self):
818 print "Tests the RDN"""
822 "dn": "description=xyz,cn=users," + self.base_dn,
823 "objectclass": "group"})
825 except LdbError, (num, _):
826 self.assertEquals(num, ERR_NAMING_VIOLATION)
828 self.delete_force(self.ldb, "description=xyz,cn=users," + self.base_dn)
830 # a wrong "name" attribute is obviously tolerated
832 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
833 "objectclass": "group",
834 "name": "ldaptestgroupx"})
836 # proof if the name has been set correctly
837 res = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
838 scope=SCOPE_BASE, attrs=["name"])
839 self.assertTrue(len(res) == 1)
840 self.assertTrue("name" in res[0])
841 self.assertTrue(res[0]["name"][0] == "ldaptestgroup")
844 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
845 m["name"] = MessageElement("cn=ldaptestuser", FLAG_MOD_REPLACE,
850 except LdbError, (num, _):
851 self.assertEquals(num, ERR_NOT_ALLOWED_ON_RDN)
854 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
855 m["cn"] = MessageElement("ldaptestuser",
856 FLAG_MOD_REPLACE, "cn")
860 except LdbError, (num, _):
861 self.assertEquals(num, ERR_NOT_ALLOWED_ON_RDN)
863 self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
866 # this test needs to be disabled until we really understand
867 # what the rDN length constraints are
868 def DISABLED_test_largeRDN(self):
869 """Testing large rDN (limit 64 characters)"""
870 rdn = "CN=a012345678901234567890123456789012345678901234567890123456789012";
871 self.delete_force(self.ldb, "%s,%s" % (rdn, self.base_dn))
873 dn: %s,%s""" % (rdn,self.base_dn) + """
874 objectClass: container
876 self.ldb.add_ldif(ldif)
877 self.delete_force(self.ldb, "%s,%s" % (rdn, self.base_dn))
879 rdn = "CN=a0123456789012345678901234567890123456789012345678901234567890120";
880 self.delete_force(self.ldb, "%s,%s" % (rdn, self.base_dn))
883 dn: %s,%s""" % (rdn,self.base_dn) + """
884 objectClass: container
886 self.ldb.add_ldif(ldif)
888 except LdbError, (num, _):
889 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
890 self.delete_force(self.ldb, "%s,%s" % (rdn, self.base_dn))
892 def test_rename(self):
893 """Tests the rename operation"""
894 print "Tests the rename operations"""
897 # cannot rename to be a child of itself
898 ldb.rename(self.base_dn, "dc=test," + self.base_dn)
900 except LdbError, (num, _):
901 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
905 ldb.rename("cn=ldaptestuser2,cn=users," + self.base_dn, "cn=ldaptestuser2,cn=users," + self.base_dn)
907 except LdbError, (num, _):
908 self.assertEquals(num, ERR_NO_SUCH_OBJECT)
911 "dn": "cn=ldaptestuser2,cn=users," + self.base_dn,
912 "objectclass": ["user", "person"] })
914 ldb.rename("cn=ldaptestuser2,cn=users," + self.base_dn, "cn=ldaptestuser2,cn=users," + self.base_dn)
915 ldb.rename("cn=ldaptestuser2,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=users," + self.base_dn)
916 ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestUSER3,cn=users," + self.base_dn)
919 # containment problem: a user entry cannot contain user entries
920 ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser4,cn=ldaptestuser3,cn=users," + self.base_dn)
922 except LdbError, (num, _):
923 self.assertEquals(num, ERR_NAMING_VIOLATION)
927 ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=people,cn=users," + self.base_dn)
929 except LdbError, (num, _):
930 self.assertEquals(num, ERR_OTHER)
933 # invalid target DN syntax
934 ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, ",cn=users," + self.base_dn)
936 except LdbError, (num, _):
937 self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
941 ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "ou=ldaptestuser3,cn=users," + self.base_dn)
943 except LdbError, (num, _):
944 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
946 self.delete_force(self.ldb, "cn=ldaptestuser3,cn=users," + self.base_dn)
948 # Performs some "systemFlags" testing
950 # Move failing since no "SYSTEM_FLAG_CONFIG_ALLOW_MOVE"
952 ldb.rename("CN=DisplaySpecifiers," + self.configuration_dn, "CN=DisplaySpecifiers,CN=Services," + self.configuration_dn)
954 except LdbError, (num, _):
955 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
957 # Limited move failing since no "SYSTEM_FLAG_CONFIG_ALLOW_LIMITED_MOVE"
959 ldb.rename("CN=Directory Service,CN=Windows NT,CN=Services," + self.configuration_dn, "CN=Directory Service,CN=RRAS,CN=Services," + self.configuration_dn)
961 except LdbError, (num, _):
962 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
964 # Rename failing since no "SYSTEM_FLAG_CONFIG_ALLOW_RENAME"
966 ldb.rename("CN=DisplaySpecifiers," + self.configuration_dn, "CN=DisplaySpecifiers2," + self.configuration_dn)
968 except LdbError, (num, _):
969 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
971 # It's not really possible to test moves on the schema partition since
972 # there don't exist subcontainers on it.
974 # Rename failing since "SYSTEM_FLAG_SCHEMA_BASE_OBJECT"
976 ldb.rename("CN=Top," + self.schema_dn, "CN=Top2," + self.schema_dn)
978 except LdbError, (num, _):
979 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
981 # Move failing since "SYSTEM_FLAG_DOMAIN_DISALLOW_MOVE"
983 ldb.rename("CN=Users," + self.base_dn, "CN=Users,CN=Computers," + self.base_dn)
985 except LdbError, (num, _):
986 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
988 # Rename failing since "SYSTEM_FLAG_DOMAIN_DISALLOW_RENAME"
990 ldb.rename("CN=Users," + self.base_dn, "CN=Users2," + self.base_dn)
992 except LdbError, (num, _):
993 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
995 # Performs some other constraints testing
998 ldb.rename("CN=Policies,CN=System," + self.base_dn, "CN=Users2," + self.base_dn)
1000 except LdbError, (num, _):
1001 self.assertEquals(num, ERR_OTHER)
1003 def test_rename_twice(self):
1004 """Tests the rename operation twice - this corresponds to a past bug"""
1005 print "Tests the rename twice operation"""
1008 "dn": "cn=ldaptestuser5,cn=users," + self.base_dn,
1009 "objectclass": ["user", "person"] })
1011 ldb.rename("cn=ldaptestuser5,cn=users," + self.base_dn, "cn=ldaptestUSER5,cn=users," + self.base_dn)
1012 self.delete_force(self.ldb, "cn=ldaptestuser5,cn=users," + self.base_dn)
1014 "dn": "cn=ldaptestuser5,cn=users," + self.base_dn,
1015 "objectclass": ["user", "person"] })
1016 ldb.rename("cn=ldaptestuser5,cn=Users," + self.base_dn, "cn=ldaptestUSER5,cn=users," + self.base_dn)
1017 res = ldb.search(expression="cn=ldaptestuser5")
1018 print "Found %u records" % len(res)
1019 self.assertEquals(len(res), 1, "Wrong number of hits for cn=ldaptestuser5")
1020 res = ldb.search(expression="(&(cn=ldaptestuser5)(objectclass=user))")
1021 print "Found %u records" % len(res)
1022 self.assertEquals(len(res), 1, "Wrong number of hits for (&(cn=ldaptestuser5)(objectclass=user))")
1023 self.delete_force(self.ldb, "cn=ldaptestuser5,cn=users," + self.base_dn)
1025 def test_parentGUID(self):
1026 """Test parentGUID behaviour"""
1027 print "Testing parentGUID behaviour\n"
1029 # TODO: This seems to fail on Windows Server. Hidden attribute?
1032 "dn": "cn=parentguidtest,cn=users," + self.base_dn,
1033 "objectclass":"user",
1034 "samaccountname":"parentguidtest"});
1035 res1 = ldb.search(base="cn=parentguidtest,cn=users," + self.base_dn, scope=SCOPE_BASE,
1036 attrs=["parentGUID", "samaccountname"]);
1037 res2 = ldb.search(base="cn=users," + self.base_dn,scope=SCOPE_BASE,
1038 attrs=["objectGUID"]);
1039 res3 = ldb.search(base=self.base_dn, scope=SCOPE_BASE,
1040 attrs=["parentGUID"]);
1042 """Check if the parentGUID is valid """
1043 self.assertEquals(res1[0]["parentGUID"], res2[0]["objectGUID"]);
1045 """Check if it returns nothing when there is no parent object"""
1046 has_parentGUID = False
1047 for key in res3[0].keys():
1048 if key == "parentGUID":
1049 has_parentGUID = True
1051 self.assertFalse(has_parentGUID);
1053 """Ensures that if you look for another object attribute after the constructed
1054 parentGUID, it will return correctly"""
1055 has_another_attribute = False
1056 for key in res1[0].keys():
1057 if key == "sAMAccountName":
1058 has_another_attribute = True
1060 self.assertTrue(has_another_attribute)
1061 self.assertTrue(len(res1[0]["samaccountname"]) == 1)
1062 self.assertEquals(res1[0]["samaccountname"][0], "parentguidtest");
1064 print "Testing parentGUID behaviour on rename\n"
1067 "dn": "cn=testotherusers," + self.base_dn,
1068 "objectclass":"container"});
1069 res1 = ldb.search(base="cn=testotherusers," + self.base_dn,scope=SCOPE_BASE,
1070 attrs=["objectGUID"]);
1071 ldb.rename("cn=parentguidtest,cn=users," + self.base_dn,
1072 "cn=parentguidtest,cn=testotherusers," + self.base_dn);
1073 res2 = ldb.search(base="cn=parentguidtest,cn=testotherusers," + self.base_dn,
1075 attrs=["parentGUID"]);
1076 self.assertEquals(res1[0]["objectGUID"], res2[0]["parentGUID"]);
1078 self.delete_force(self.ldb, "cn=parentguidtest,cn=testotherusers," + self.base_dn)
1079 self.delete_force(self.ldb, "cn=testotherusers," + self.base_dn)
1081 def test_groupType_int32(self):
1082 """Test groupType (int32) behaviour (should appear to be casted to a 32 bit signed integer before comparsion)"""
1083 print "Testing groupType (int32) behaviour\n"
1085 res1 = ldb.search(base=self.base_dn, scope=SCOPE_SUBTREE,
1086 attrs=["groupType"], expression="groupType=2147483653");
1088 res2 = ldb.search(base=self.base_dn, scope=SCOPE_SUBTREE,
1089 attrs=["groupType"], expression="groupType=-2147483643");
1091 self.assertEquals(len(res1), len(res2))
1093 self.assertTrue(res1.count > 0)
1095 self.assertEquals(res1[0]["groupType"][0], "-2147483643")
1097 def test_linked_attributes(self):
1098 """This tests the linked attribute behaviour"""
1099 print "Testing linked attribute behaviour\n"
1102 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
1103 "objectclass": "group"})
1105 # This should not work since "memberOf" is linked to "member"
1108 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
1109 "objectclass": ["user", "person"],
1110 "memberOf": "cn=ldaptestgroup,cn=users," + self.base_dn})
1111 except LdbError, (num, _):
1112 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1115 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
1116 "objectclass": ["user", "person"]})
1119 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1120 m["memberOf"] = MessageElement("cn=ldaptestgroup,cn=users," + self.base_dn,
1121 FLAG_MOD_ADD, "memberOf")
1125 except LdbError, (num, _):
1126 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1129 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1130 m["member"] = MessageElement("cn=ldaptestuser,cn=users," + self.base_dn,
1131 FLAG_MOD_ADD, "member")
1135 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1136 m["memberOf"] = MessageElement("cn=ldaptestgroup,cn=users," + self.base_dn,
1137 FLAG_MOD_REPLACE, "memberOf")
1141 except LdbError, (num, _):
1142 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1145 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1146 m["memberOf"] = MessageElement("cn=ldaptestgroup,cn=users," + self.base_dn,
1147 FLAG_MOD_DELETE, "memberOf")
1151 except LdbError, (num, _):
1152 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1155 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1156 m["member"] = MessageElement("cn=ldaptestuser,cn=users," + self.base_dn,
1157 FLAG_MOD_DELETE, "member")
1160 # This should yield no results since the member attribute for
1161 # "ldaptestuser" should have been deleted
1162 res1 = ldb.search("cn=ldaptestgroup, cn=users," + self.base_dn,
1164 expression="(member=cn=ldaptestuser,cn=users," + self.base_dn + ")",
1166 self.assertTrue(len(res1) == 0)
1168 self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1171 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
1172 "objectclass": "group",
1173 "member": "cn=ldaptestuser,cn=users," + self.base_dn})
1175 self.delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1177 # Make sure that the "member" attribute for "ldaptestuser" has been
1179 res = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
1180 scope=SCOPE_BASE, attrs=["member"])
1181 self.assertTrue(len(res) == 1)
1182 self.assertFalse("member" in res[0])
1184 self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1186 def test_groups(self):
1187 """This tests the group behaviour (setting, changing) of a user account"""
1188 print "Testing group behaviour\n"
1191 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
1192 "objectclass": "group"})
1195 "dn": "cn=ldaptestgroup2,cn=users," + self.base_dn,
1196 "objectclass": "group"})
1198 res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
1199 scope=SCOPE_BASE, attrs=["objectSID"])
1200 self.assertTrue(len(res1) == 1)
1201 group_rid_1 = security.dom_sid(ldb.schema_format_value("objectSID",
1202 res1[0]["objectSID"][0])).split()[1]
1204 res1 = ldb.search("cn=ldaptestgroup2,cn=users," + self.base_dn,
1205 scope=SCOPE_BASE, attrs=["objectSID"])
1206 self.assertTrue(len(res1) == 1)
1207 group_rid_2 = security.dom_sid(ldb.schema_format_value("objectSID",
1208 res1[0]["objectSID"][0])).split()[1]
1210 # Try to create a user with an invalid primary group
1213 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
1214 "objectclass": ["user", "person"],
1215 "primaryGroupID": "0"})
1217 except LdbError, (num, _):
1218 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1219 self.delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1221 # Try to Create a user with a valid primary group
1222 # TODO Some more investigation needed here
1225 # "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
1226 # "objectclass": ["user", "person"],
1227 # "primaryGroupID": str(group_rid_1)})
1229 # except LdbError, (num, _):
1230 # self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1231 # self.delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1233 # Test to see how we should behave when the user account doesn't
1236 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1237 m["primaryGroupID"] = MessageElement("0", FLAG_MOD_REPLACE,
1242 except LdbError, (num, _):
1243 self.assertEquals(num, ERR_NO_SUCH_OBJECT)
1245 # Test to see how we should behave when the account isn't a user
1247 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1248 m["primaryGroupID"] = MessageElement("0", FLAG_MOD_REPLACE,
1253 except LdbError, (num, _):
1254 self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
1256 # Test default primary groups
1259 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
1260 "objectclass": ["user", "person"]})
1262 res1 = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
1263 scope=SCOPE_BASE, attrs=["primaryGroupID"])
1264 self.assertTrue(len(res1) == 1)
1265 self.assertEquals(res1[0]["primaryGroupID"][0], str(DOMAIN_RID_USERS))
1267 self.delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1270 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
1271 "objectclass": ["user", "person"],
1272 "userAccountControl": str(UF_NORMAL_ACCOUNT | UF_PASSWD_NOTREQD) })
1274 res1 = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
1275 scope=SCOPE_BASE, attrs=["primaryGroupID"])
1276 self.assertTrue(len(res1) == 1)
1277 self.assertEquals(res1[0]["primaryGroupID"][0], str(DOMAIN_RID_USERS))
1279 self.delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1281 # unfortunately the INTERDOMAIN_TRUST_ACCOUNT case cannot be tested
1282 # since such accounts aren't directly creatable (ACCESS_DENIED)
1285 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
1286 "objectclass": ["computer"],
1287 "userAccountControl": str(UF_SERVER_TRUST_ACCOUNT | UF_PASSWD_NOTREQD) })
1289 res1 = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
1290 scope=SCOPE_BASE, attrs=["primaryGroupID"])
1291 self.assertTrue(len(res1) == 1)
1292 self.assertEquals(res1[0]["primaryGroupID"][0], str(DOMAIN_RID_DCS))
1294 self.delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1296 # Recreate account for further tests
1299 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
1300 "objectclass": ["user", "person"]})
1302 # We should be able to reset our actual primary group
1304 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1305 m["primaryGroupID"] = MessageElement(str(DOMAIN_RID_USERS), FLAG_MOD_REPLACE,
1309 # Try to add invalid primary group
1311 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1312 m["primaryGroupID"] = MessageElement("0", FLAG_MOD_REPLACE,
1317 except LdbError, (num, _):
1318 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1320 # Try to make group 1 primary - should be denied since it is not yet
1323 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1324 m["primaryGroupID"] = MessageElement(str(group_rid_1),
1325 FLAG_MOD_REPLACE, "primaryGroupID")
1329 except LdbError, (num, _):
1330 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1332 # Make group 1 secondary
1334 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1335 m["member"] = MessageElement("cn=ldaptestuser,cn=users," + self.base_dn,
1336 FLAG_MOD_REPLACE, "member")
1339 # Make group 1 primary
1341 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1342 m["primaryGroupID"] = MessageElement(str(group_rid_1),
1343 FLAG_MOD_REPLACE, "primaryGroupID")
1346 # Try to delete group 1 - should be denied
1348 ldb.delete("cn=ldaptestgroup,cn=users," + self.base_dn)
1350 except LdbError, (num, _):
1351 self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
1353 # Try to add group 1 also as secondary - should be denied
1355 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1356 m["member"] = MessageElement("cn=ldaptestuser,cn=users," + self.base_dn,
1357 FLAG_MOD_ADD, "member")
1361 except LdbError, (num, _):
1362 self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
1364 # Try to add invalid member to group 1 - should be denied
1366 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1367 m["member"] = MessageElement(
1368 "cn=ldaptestuser3,cn=users," + self.base_dn,
1369 FLAG_MOD_ADD, "member")
1373 except LdbError, (num, _):
1374 self.assertEquals(num, ERR_NO_SUCH_OBJECT)
1376 # Make group 2 secondary
1378 m.dn = Dn(ldb, "cn=ldaptestgroup2,cn=users," + self.base_dn)
1379 m["member"] = MessageElement("cn=ldaptestuser,cn=users," + self.base_dn,
1380 FLAG_MOD_ADD, "member")
1385 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1386 m["primaryGroupID"] = MessageElement(str(group_rid_2),
1387 FLAG_MOD_REPLACE, "primaryGroupID")
1390 # Old primary group should contain a "member" attribute for the user,
1391 # the new shouldn't contain anymore one
1392 res1 = ldb.search("cn=ldaptestgroup, cn=users," + self.base_dn,
1393 scope=SCOPE_BASE, attrs=["member"])
1394 self.assertTrue(len(res1) == 1)
1395 self.assertTrue(len(res1[0]["member"]) == 1)
1396 self.assertEquals(res1[0]["member"][0].lower(),
1397 ("cn=ldaptestuser,cn=users," + self.base_dn).lower())
1399 res1 = ldb.search("cn=ldaptestgroup2, cn=users," + self.base_dn,
1400 scope=SCOPE_BASE, attrs=["member"])
1401 self.assertTrue(len(res1) == 1)
1402 self.assertFalse("member" in res1[0])
1404 # Also this should be denied
1407 "dn": "cn=ldaptestuser1,cn=users," + self.base_dn,
1408 "objectclass": ["user", "person"],
1409 "primaryGroupID": "0"})
1411 except LdbError, (num, _):
1412 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1414 self.delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1415 self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1416 self.delete_force(self.ldb, "cn=ldaptestgroup2,cn=users," + self.base_dn)
1418 def test_sam_attributes(self):
1419 """Test the behaviour of special attributes of SAM objects"""
1420 print "Testing the behaviour of special attributes of SAM objects\n"""
1423 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
1424 "objectclass": ["user", "person"]})
1426 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
1427 "objectclass": "group"})
1430 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1431 m["groupType"] = MessageElement("0", FLAG_MOD_ADD,
1436 except LdbError, (num, _):
1437 self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
1440 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1441 m["groupType"] = MessageElement([], FLAG_MOD_DELETE,
1446 except LdbError, (num, _):
1447 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1450 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1451 m["primaryGroupID"] = MessageElement("0", FLAG_MOD_ADD,
1456 except LdbError, (num, _):
1457 self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
1460 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1461 m["primaryGroupID"] = MessageElement([], FLAG_MOD_DELETE,
1466 except LdbError, (num, _):
1467 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1470 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1471 m["userAccountControl"] = MessageElement("0", FLAG_MOD_ADD,
1472 "userAccountControl")
1476 except LdbError, (num, _):
1477 self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
1480 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1481 m["userAccountControl"] = MessageElement([], FLAG_MOD_DELETE,
1482 "userAccountControl")
1486 except LdbError, (num, _):
1487 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1490 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1491 m["sAMAccountType"] = MessageElement("0", FLAG_MOD_ADD,
1496 except LdbError, (num, _):
1497 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1500 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1501 m["sAMAccountType"] = MessageElement([], FLAG_MOD_REPLACE,
1506 except LdbError, (num, _):
1507 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1510 m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1511 m["sAMAccountType"] = MessageElement([], FLAG_MOD_DELETE,
1516 except LdbError, (num, _):
1517 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1519 self.delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1520 self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1522 def test_primary_group_token_constructed(self):
1523 """Test the primary group token behaviour (hidden-generated-readonly attribute on groups) and some other constructed attributes"""
1524 print "Testing primary group token behaviour and other constructed attributes\n"
1528 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
1529 "objectclass": "group",
1530 "primaryGroupToken": "100"})
1532 except LdbError, (num, _):
1533 self.assertEquals(num, ERR_UNDEFINED_ATTRIBUTE_TYPE)
1534 self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1537 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
1538 "objectclass": ["user", "person"]})
1541 "dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
1542 "objectclass": "group"})
1544 # Testing for one invalid, and one valid operational attribute, but also the things they are built from
1545 res1 = ldb.search(self.base_dn,
1546 scope=SCOPE_BASE, attrs=["primaryGroupToken", "canonicalName", "objectClass", "objectSid"])
1547 self.assertTrue(len(res1) == 1)
1548 self.assertFalse("primaryGroupToken" in res1[0])
1549 self.assertTrue("canonicalName" in res1[0])
1550 self.assertTrue("objectClass" in res1[0])
1551 self.assertTrue("objectSid" in res1[0])
1553 res1 = ldb.search(self.base_dn,
1554 scope=SCOPE_BASE, attrs=["primaryGroupToken", "canonicalName"])
1555 self.assertTrue(len(res1) == 1)
1556 self.assertFalse("primaryGroupToken" in res1[0])
1557 self.assertFalse("objectSid" in res1[0])
1558 self.assertFalse("objectClass" in res1[0])
1559 self.assertTrue("canonicalName" in res1[0])
1561 res1 = ldb.search("cn=users,"+self.base_dn,
1562 scope=SCOPE_BASE, attrs=["primaryGroupToken"])
1563 self.assertTrue(len(res1) == 1)
1564 self.assertFalse("primaryGroupToken" in res1[0])
1566 res1 = ldb.search("cn=ldaptestuser, cn=users," + self.base_dn,
1567 scope=SCOPE_BASE, attrs=["primaryGroupToken"])
1568 self.assertTrue(len(res1) == 1)
1569 self.assertFalse("primaryGroupToken" in res1[0])
1571 res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
1573 self.assertTrue(len(res1) == 1)
1574 self.assertFalse("primaryGroupToken" in res1[0])
1576 res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
1577 scope=SCOPE_BASE, attrs=["primaryGroupToken", "objectSID"])
1578 self.assertTrue(len(res1) == 1)
1579 primary_group_token = int(res1[0]["primaryGroupToken"][0])
1581 rid = security.dom_sid(ldb.schema_format_value("objectSID", res1[0]["objectSID"][0])).split()[1]
1582 self.assertEquals(primary_group_token, rid)
1585 m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1586 m["primaryGroupToken"] = "100"
1590 except LdbError, (num, _):
1591 self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
1593 self.delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1594 self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
1596 def test_tokenGroups(self):
1597 """Test the tokenGroups behaviour (hidden-generated-readonly attribute on SAM objects)"""
1598 print "Testing tokenGroups behaviour\n"
1600 # The domain object shouldn't contain any "tokenGroups" entry
1601 res = ldb.search(self.base_dn, scope=SCOPE_BASE, attrs=["tokenGroups"])
1602 self.assertTrue(len(res) == 1)
1603 self.assertFalse("tokenGroups" in res[0])
1605 # The domain administrator should contain "tokenGroups" entries
1606 # (the exact number depends on the domain/forest function level and the
1607 # DC software versions)
1608 res = ldb.search("cn=Administrator,cn=Users," + self.base_dn,
1609 scope=SCOPE_BASE, attrs=["tokenGroups"])
1610 self.assertTrue(len(res) == 1)
1611 self.assertTrue("tokenGroups" in res[0])
1614 "dn": "cn=ldaptestuser,cn=users," + self.base_dn,
1615 "objectclass": ["user", "person"]})
1617 # This testuser should contain at least two "tokenGroups" entries
1618 # (exactly two on an unmodified "Domain Users" and "Users" group)
1619 res = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
1620 scope=SCOPE_BASE, attrs=["tokenGroups"])
1621 self.assertTrue(len(res) == 1)
1622 self.assertTrue(len(res[0]["tokenGroups"]) >= 2)
1624 # one entry which we need to find should point to domains "Domain Users"
1625 # group and another entry should point to the builtin "Users"group
1626 domain_users_group_found = False
1627 users_group_found = False
1628 for sid in res[0]["tokenGroups"]:
1629 rid = security.dom_sid(ldb.schema_format_value("objectSID", sid)).split()[1]
1631 domain_users_group_found = True
1633 users_group_found = True
1635 self.assertTrue(domain_users_group_found)
1636 self.assertTrue(users_group_found)
1638 self.delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
1640 def test_wkguid(self):
1641 """Test Well known GUID behaviours (including DN+Binary)"""
1642 print "Test Well known GUID behaviours (including DN+Binary)"""
1644 res = self.ldb.search(base=("<WKGUID=ab1d30f3768811d1aded00c04fd8d5cd,%s>" % self.base_dn), scope=SCOPE_BASE, attrs=[])
1645 self.assertEquals(len(res), 1)
1647 res2 = self.ldb.search(scope=SCOPE_BASE, attrs=["wellKnownObjects"], expression=("wellKnownObjects=B:32:ab1d30f3768811d1aded00c04fd8d5cd:%s" % res[0].dn))
1648 self.assertEquals(len(res2), 1)
1650 # Prove that the matching rule is over the whole DN+Binary
1651 res2 = self.ldb.search(scope=SCOPE_BASE, attrs=["wellKnownObjects"], expression=("wellKnownObjects=B:32:ab1d30f3768811d1aded00c04fd8d5cd"))
1652 self.assertEquals(len(res2), 0)
1653 # Prove that the matching rule is over the whole DN+Binary
1654 res2 = self.ldb.search(scope=SCOPE_BASE, attrs=["wellKnownObjects"], expression=("wellKnownObjects=%s") % res[0].dn)
1655 self.assertEquals(len(res2), 0)
1657 def test_subschemasubentry(self):
1658 """Test subSchemaSubEntry appears when requested, but not when not requested"""
1659 print "Test subSchemaSubEntry"""
1661 res = self.ldb.search(base=self.base_dn, scope=SCOPE_BASE, attrs=["subSchemaSubEntry"])
1662 self.assertEquals(len(res), 1)
1663 self.assertEquals(res[0]["subSchemaSubEntry"][0], "CN=Aggregate,"+self.schema_dn)
1665 res = self.ldb.search(base=self.base_dn, scope=SCOPE_BASE, attrs=["*"])
1666 self.assertEquals(len(res), 1)
1667 self.assertTrue("subScheamSubEntry" not in res[0])
1669 def test_delete(self):
1670 """Tests the delete operation"""
1671 print "Tests the delete operations"""
1674 "dn": "cn=ldaptestcontainer," + self.base_dn,
1675 "objectclass": "container"})
1677 "dn": "cn=entry1,cn=ldaptestcontainer," + self.base_dn,
1678 "objectclass": "container"})
1680 "dn": "cn=entry2,cn=ldaptestcontainer," + self.base_dn,
1681 "objectclass": "container"})
1684 ldb.delete("cn=ldaptestcontainer," + self.base_dn)
1686 except LdbError, (num, _):
1687 self.assertEquals(num, ERR_NOT_ALLOWED_ON_NON_LEAF)
1689 ldb.delete("cn=ldaptestcontainer," + self.base_dn, ["tree_delete:0"])
1692 res = ldb.search("cn=ldaptestcontainer," + self.base_dn,
1693 scope=SCOPE_BASE, attrs=[])
1695 except LdbError, (num, _):
1696 self.assertEquals(num, ERR_NO_SUCH_OBJECT)
1698 res = ldb.search("cn=entry1,cn=ldaptestcontainer," + self.base_dn,
1699 scope=SCOPE_BASE, attrs=[])
1701 except LdbError, (num, _):
1702 self.assertEquals(num, ERR_NO_SUCH_OBJECT)
1704 res = ldb.search("cn=entry2,cn=ldaptestcontainer," + self.base_dn,
1705 scope=SCOPE_BASE, attrs=[])
1707 except LdbError, (num, _):
1708 self.assertEquals(num, ERR_NO_SUCH_OBJECT)
1710 self.delete_force(self.ldb, "cn=entry1,cn=ldaptestcontainer," + self.base_dn)
1711 self.delete_force(self.ldb, "cn=entry2,cn=ldaptestcontainer," + self.base_dn)
1712 self.delete_force(self.ldb, "cn=ldaptestcontainer," + self.base_dn)
1714 # Performs some protected object delete testing
1716 res = ldb.search(base="", expression="", scope=SCOPE_BASE,
1717 attrs=["dsServiceName", "dNSHostName"])
1718 self.assertEquals(len(res), 1)
1721 ldb.delete(res[0]["dsServiceName"][0])
1723 except LdbError, (num, _):
1724 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1726 res = ldb.search(self.base_dn, scope=SCOPE_SUBTREE,
1727 attrs=["rIDSetReferences"],
1728 expression="(&(objectClass=computer)(dNSHostName=" + res[0]["dNSHostName"][0] + "))")
1729 self.assertEquals(len(res), 1)
1732 ldb.delete(res[0]["rIDSetReferences"][0])
1734 except LdbError, (num, _):
1735 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1738 ldb.delete("cn=Enterprise Schema,cn=Partitions," + self.configuration_dn)
1740 except LdbError, (num, _):
1741 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1743 # TODO: This fails with LDB_ERR_NOT_ALLOWED_ON_NON_LEAF on Windows
1745 # ldb.delete("cn=Enterprise Configuration,cn=Partitions," + self.configuration_dn)
1747 # except LdbError, (num, _):
1748 # self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1750 # Performs some "systemFlags" testing
1752 # Delete failing since "SYSTEM_FLAG_DISALLOW_DELETE"
1754 ldb.delete("CN=Users," + self.base_dn)
1756 except LdbError, (num, _):
1757 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1762 print "Testing user add"
1765 "dn": "cn=ldaptestuser,cn=uSers," + self.base_dn,
1766 "objectclass": ["user", "person"],
1767 "cN": "LDAPtestUSER",
1768 "givenname": "ldap",
1772 "dn": "cn=ldaptestgroup,cn=uSers," + self.base_dn,
1773 "objectclass": "group",
1774 "member": "cn=ldaptestuser,cn=useRs," + self.base_dn})
1777 "dn": "cn=ldaptestcomputer,cn=computers," + self.base_dn,
1778 "objectclass": "computer",
1779 "cN": "LDAPtestCOMPUTER"})
1781 ldb.add({"dn": "cn=ldaptest2computer,cn=computers," + self.base_dn,
1782 "objectClass": "computer",
1783 "cn": "LDAPtest2COMPUTER",
1784 "userAccountControl": str(UF_WORKSTATION_TRUST_ACCOUNT),
1785 "displayname": "ldap testy"})
1788 ldb.add({"dn": "cn=ldaptestcomputer3,cn=computers," + self.base_dn,
1789 "objectClass": "computer",
1790 "cn": "LDAPtest2COMPUTER"
1793 except LdbError, (num, _):
1794 self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
1797 ldb.add({"dn": "cn=ldaptestcomputer3,cn=computers," + self.base_dn,
1798 "objectClass": "computer",
1799 "cn": "ldaptestcomputer3",
1800 "sAMAccountType": str(ATYPE_NORMAL_ACCOUNT)
1803 except LdbError, (num, _):
1804 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
1806 ldb.add({"dn": "cn=ldaptestcomputer3,cn=computers," + self.base_dn,
1807 "objectClass": "computer",
1808 "cn": "LDAPtestCOMPUTER3"
1811 print "Testing ldb.search for (&(cn=ldaptestcomputer3)(objectClass=user))";
1812 res = ldb.search(self.base_dn, expression="(&(cn=ldaptestcomputer3)(objectClass=user))");
1813 self.assertEquals(len(res), 1, "Found only %d for (&(cn=ldaptestcomputer3)(objectClass=user))" % len(res))
1815 self.assertEquals(str(res[0].dn), ("CN=ldaptestcomputer3,CN=Computers," + self.base_dn));
1816 self.assertEquals(res[0]["cn"][0], "ldaptestcomputer3");
1817 self.assertEquals(res[0]["name"][0], "ldaptestcomputer3");
1818 self.assertEquals(res[0]["objectClass"][0], "top");
1819 self.assertEquals(res[0]["objectClass"][1], "person");
1820 self.assertEquals(res[0]["objectClass"][2], "organizationalPerson");
1821 self.assertEquals(res[0]["objectClass"][3], "user");
1822 self.assertEquals(res[0]["objectClass"][4], "computer");
1823 self.assertTrue("objectGUID" in res[0])
1824 self.assertTrue("whenCreated" in res[0])
1825 self.assertEquals(res[0]["objectCategory"][0], ("CN=Computer,CN=Schema,CN=Configuration," + self.base_dn));
1826 self.assertEquals(int(res[0]["primaryGroupID"][0]), 513);
1827 self.assertEquals(int(res[0]["sAMAccountType"][0]), ATYPE_NORMAL_ACCOUNT);
1828 self.assertEquals(int(res[0]["userAccountControl"][0]), UF_NORMAL_ACCOUNT | UF_PASSWD_NOTREQD | UF_ACCOUNTDISABLE);
1830 self.delete_force(self.ldb, "cn=ldaptestcomputer3,cn=computers," + self.base_dn)
1832 print "Testing attribute or value exists behaviour"
1835 dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """
1837 replace: servicePrincipalName
1838 servicePrincipalName: host/ldaptest2computer
1839 servicePrincipalName: host/ldaptest2computer
1840 servicePrincipalName: cifs/ldaptest2computer
1843 except LdbError, (num, msg):
1844 self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
1847 dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """
1849 replace: servicePrincipalName
1850 servicePrincipalName: host/ldaptest2computer
1851 servicePrincipalName: cifs/ldaptest2computer
1855 dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """
1857 add: servicePrincipalName
1858 servicePrincipalName: host/ldaptest2computer
1861 except LdbError, (num, msg):
1862 self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
1864 print "Testing ranged results"
1866 dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """
1868 replace: servicePrincipalName
1872 dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """
1874 add: servicePrincipalName
1875 servicePrincipalName: host/ldaptest2computer0
1876 servicePrincipalName: host/ldaptest2computer1
1877 servicePrincipalName: host/ldaptest2computer2
1878 servicePrincipalName: host/ldaptest2computer3
1879 servicePrincipalName: host/ldaptest2computer4
1880 servicePrincipalName: host/ldaptest2computer5
1881 servicePrincipalName: host/ldaptest2computer6
1882 servicePrincipalName: host/ldaptest2computer7
1883 servicePrincipalName: host/ldaptest2computer8
1884 servicePrincipalName: host/ldaptest2computer9
1885 servicePrincipalName: host/ldaptest2computer10
1886 servicePrincipalName: host/ldaptest2computer11
1887 servicePrincipalName: host/ldaptest2computer12
1888 servicePrincipalName: host/ldaptest2computer13
1889 servicePrincipalName: host/ldaptest2computer14
1890 servicePrincipalName: host/ldaptest2computer15
1891 servicePrincipalName: host/ldaptest2computer16
1892 servicePrincipalName: host/ldaptest2computer17
1893 servicePrincipalName: host/ldaptest2computer18
1894 servicePrincipalName: host/ldaptest2computer19
1895 servicePrincipalName: host/ldaptest2computer20
1896 servicePrincipalName: host/ldaptest2computer21
1897 servicePrincipalName: host/ldaptest2computer22
1898 servicePrincipalName: host/ldaptest2computer23
1899 servicePrincipalName: host/ldaptest2computer24
1900 servicePrincipalName: host/ldaptest2computer25
1901 servicePrincipalName: host/ldaptest2computer26
1902 servicePrincipalName: host/ldaptest2computer27
1903 servicePrincipalName: host/ldaptest2computer28
1904 servicePrincipalName: host/ldaptest2computer29
1907 res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE,
1908 attrs=["servicePrincipalName;range=0-*"])
1909 self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
1910 #print len(res[0]["servicePrincipalName;range=0-*"])
1911 self.assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30)
1913 res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-19"])
1914 self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
1915 # print res[0]["servicePrincipalName;range=0-19"].length
1916 self.assertEquals(len(res[0]["servicePrincipalName;range=0-19"]), 20)
1919 res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-30"])
1920 self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
1921 self.assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30)
1923 res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-40"])
1924 self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
1925 self.assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30)
1927 res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=30-40"])
1928 self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
1929 self.assertEquals(len(res[0]["servicePrincipalName;range=30-*"]), 0)
1932 res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=10-40"])
1933 self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
1934 self.assertEquals(len(res[0]["servicePrincipalName;range=10-*"]), 20)
1935 # pos_11 = res[0]["servicePrincipalName;range=10-*"][18]
1937 res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=11-40"])
1938 self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
1939 self.assertEquals(len(res[0]["servicePrincipalName;range=11-*"]), 19)
1940 # print res[0]["servicePrincipalName;range=11-*"][18]
1942 # self.assertEquals((res[0]["servicePrincipalName;range=11-*"][18]), pos_11)
1944 res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=11-15"])
1945 self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
1946 self.assertEquals(len(res[0]["servicePrincipalName;range=11-15"]), 5)
1947 # self.assertEquals(res[0]["servicePrincipalName;range=11-15"][4], pos_11)
1949 res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName"])
1950 self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
1951 # print res[0]["servicePrincipalName"][18]
1953 self.assertEquals(len(res[0]["servicePrincipalName"]), 30)
1954 # self.assertEquals(res[0]["servicePrincipalName"][18], pos_11)
1956 self.delete_force(self.ldb, "cn=ldaptestuser2,cn=users," + self.base_dn)
1958 "dn": "cn=ldaptestuser2,cn=useRs," + self.base_dn,
1959 "objectClass": ["person", "user"],
1960 "cn": "LDAPtestUSER2",
1961 "givenname": "testy",
1962 "sn": "ldap user2"})
1964 print "Testing Ambigious Name Resolution"
1965 # Testing ldb.search for (&(anr=ldap testy)(objectClass=user))
1966 res = ldb.search(expression="(&(anr=ldap testy)(objectClass=user))")
1967 self.assertEquals(len(res), 3, "Found only %d of 3 for (&(anr=ldap testy)(objectClass=user))" % len(res))
1969 # Testing ldb.search for (&(anr=testy ldap)(objectClass=user))
1970 res = ldb.search(expression="(&(anr=testy ldap)(objectClass=user))")
1971 self.assertEquals(len(res), 2, "Found only %d of 2 for (&(anr=testy ldap)(objectClass=user))" % len(res))
1973 # Testing ldb.search for (&(anr=ldap)(objectClass=user))
1974 res = ldb.search(expression="(&(anr=ldap)(objectClass=user))")
1975 self.assertEquals(len(res), 4, "Found only %d of 4 for (&(anr=ldap)(objectClass=user))" % len(res))
1977 # Testing ldb.search for (&(anr==ldap)(objectClass=user))
1978 res = ldb.search(expression="(&(anr==ldap)(objectClass=user))")
1979 self.assertEquals(len(res), 1, "Could not find (&(anr==ldap)(objectClass=user)). Found only %d for (&(anr=ldap)(objectClass=user))" % len(res))
1981 self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn))
1982 self.assertEquals(res[0]["cn"][0], "ldaptestuser")
1983 self.assertEquals(str(res[0]["name"]), "ldaptestuser")
1985 # Testing ldb.search for (&(anr=testy)(objectClass=user))
1986 res = ldb.search(expression="(&(anr=testy)(objectClass=user))")
1987 self.assertEquals(len(res), 2, "Found only %d for (&(anr=testy)(objectClass=user))" % len(res))
1989 # Testing ldb.search for (&(anr=testy ldap)(objectClass=user))
1990 res = ldb.search(expression="(&(anr=testy ldap)(objectClass=user))")
1991 self.assertEquals(len(res), 2, "Found only %d for (&(anr=testy ldap)(objectClass=user))" % len(res))
1993 # Testing ldb.search for (&(anr==testy ldap)(objectClass=user))
1994 # this test disabled for the moment, as anr with == tests are not understood
1995 # res = ldb.search(expression="(&(anr==testy ldap)(objectClass=user))")
1996 # self.assertEquals(len(res), 1, "Found only %d for (&(anr==testy ldap)(objectClass=user))" % len(res))
1998 # self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn))
1999 # self.assertEquals(res[0]["cn"][0], "ldaptestuser")
2000 # self.assertEquals(res[0]["name"][0], "ldaptestuser")
2002 # Testing ldb.search for (&(anr==testy ldap)(objectClass=user))
2003 # res = ldb.search(expression="(&(anr==testy ldap)(objectClass=user))")
2004 # self.assertEquals(len(res), 1, "Could not find (&(anr==testy ldap)(objectClass=user))")
2006 # self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn))
2007 # self.assertEquals(res[0]["cn"][0], "ldaptestuser")
2008 # self.assertEquals(res[0]["name"][0], "ldaptestuser")
2010 # Testing ldb.search for (&(anr=testy ldap user)(objectClass=user))
2011 res = ldb.search(expression="(&(anr=testy ldap user)(objectClass=user))")
2012 self.assertEquals(len(res), 1, "Could not find (&(anr=testy ldap user)(objectClass=user))")
2014 self.assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
2015 self.assertEquals(str(res[0]["cn"]), "ldaptestuser2")
2016 self.assertEquals(str(res[0]["name"]), "ldaptestuser2")
2018 # Testing ldb.search for (&(anr==testy ldap user2)(objectClass=user))
2019 # res = ldb.search(expression="(&(anr==testy ldap user2)(objectClass=user))")
2020 # self.assertEquals(len(res), 1, "Could not find (&(anr==testy ldap user2)(objectClass=user))")
2022 self.assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
2023 self.assertEquals(str(res[0]["cn"]), "ldaptestuser2")
2024 self.assertEquals(str(res[0]["name"]), "ldaptestuser2")
2026 # Testing ldb.search for (&(anr==ldap user2)(objectClass=user))
2027 # res = ldb.search(expression="(&(anr==ldap user2)(objectClass=user))")
2028 # self.assertEquals(len(res), 1, "Could not find (&(anr==ldap user2)(objectClass=user))")
2030 self.assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
2031 self.assertEquals(str(res[0]["cn"]), "ldaptestuser2")
2032 self.assertEquals(str(res[0]["name"]), "ldaptestuser2")
2034 # Testing ldb.search for (&(anr==not ldap user2)(objectClass=user))
2035 # res = ldb.search(expression="(&(anr==not ldap user2)(objectClass=user))")
2036 # self.assertEquals(len(res), 0, "Must not find (&(anr==not ldap user2)(objectClass=user))")
2038 # Testing ldb.search for (&(anr=not ldap user2)(objectClass=user))
2039 res = ldb.search(expression="(&(anr=not ldap user2)(objectClass=user))")
2040 self.assertEquals(len(res), 0, "Must not find (&(anr=not ldap user2)(objectClass=user))")
2042 # Testing ldb.search for (&(anr="testy ldap")(objectClass=user)) (ie, with quotes)
2043 # res = ldb.search(expression="(&(anr==\"testy ldap\")(objectClass=user))")
2044 # self.assertEquals(len(res), 0, "Found (&(anr==\"testy ldap\")(objectClass=user))")
2046 print "Testing Renames"
2048 attrs = ["objectGUID", "objectSid"]
2049 print "Testing ldb.search for (&(cn=ldaptestUSer2)(objectClass=user))"
2050 res_user = ldb.search(self.base_dn, expression="(&(cn=ldaptestUSer2)(objectClass=user))", scope=SCOPE_SUBTREE, attrs=attrs)
2051 self.assertEquals(len(res_user), 1, "Could not find (&(cn=ldaptestUSer2)(objectClass=user))")
2053 # Check rename works with extended/alternate DN forms
2054 ldb.rename("<SID=" + ldb.schema_format_value("objectSID", res_user[0]["objectSID"][0]) + ">" , "cn=ldaptestUSER3,cn=users," + self.base_dn)
2056 print "Testing ldb.search for (&(cn=ldaptestuser3)(objectClass=user))"
2057 res = ldb.search(expression="(&(cn=ldaptestuser3)(objectClass=user))")
2058 self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser3)(objectClass=user))")
2060 self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
2061 self.assertEquals(str(res[0]["cn"]), "ldaptestUSER3")
2062 self.assertEquals(str(res[0]["name"]), "ldaptestUSER3")
2064 #"Testing ldb.search for (&(&(cn=ldaptestuser3)(userAccountControl=*))(objectClass=user))"
2065 res = ldb.search(expression="(&(&(cn=ldaptestuser3)(userAccountControl=*))(objectClass=user))")
2066 self.assertEquals(len(res), 1, "(&(&(cn=ldaptestuser3)(userAccountControl=*))(objectClass=user))")
2068 self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
2069 self.assertEquals(str(res[0]["cn"]), "ldaptestUSER3")
2070 self.assertEquals(str(res[0]["name"]), "ldaptestUSER3")
2072 #"Testing ldb.search for (&(&(cn=ldaptestuser3)(userAccountControl=546))(objectClass=user))"
2073 res = ldb.search(expression="(&(&(cn=ldaptestuser3)(userAccountControl=546))(objectClass=user))")
2074 self.assertEquals(len(res), 1, "(&(&(cn=ldaptestuser3)(userAccountControl=546))(objectClass=user))")
2076 self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
2077 self.assertEquals(str(res[0]["cn"]), "ldaptestUSER3")
2078 self.assertEquals(str(res[0]["name"]), "ldaptestUSER3")
2080 #"Testing ldb.search for (&(&(cn=ldaptestuser3)(userAccountControl=547))(objectClass=user))"
2081 res = ldb.search(expression="(&(&(cn=ldaptestuser3)(userAccountControl=547))(objectClass=user))")
2082 self.assertEquals(len(res), 0, "(&(&(cn=ldaptestuser3)(userAccountControl=547))(objectClass=user))")
2084 # This is a Samba special, and does not exist in real AD
2085 # print "Testing ldb.search for (dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")"
2086 # res = ldb.search("(dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")")
2087 # if (res.error != 0 || len(res) != 1) {
2088 # print "Could not find (dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")"
2089 # self.assertEquals(len(res), 1)
2091 # self.assertEquals(res[0].dn, ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
2092 # self.assertEquals(res[0].cn, "ldaptestUSER3")
2093 # self.assertEquals(res[0].name, "ldaptestUSER3")
2095 print "Testing ldb.search for (distinguishedName=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")"
2096 res = ldb.search(expression="(distinguishedName=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")")
2097 self.assertEquals(len(res), 1, "Could not find (dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")")
2098 self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
2099 self.assertEquals(str(res[0]["cn"]), "ldaptestUSER3")
2100 self.assertEquals(str(res[0]["name"]), "ldaptestUSER3")
2102 # ensure we cannot add it again
2104 ldb.add({"dn": "cn=ldaptestuser3,cn=userS," + self.base_dn,
2105 "objectClass": ["person", "user"],
2106 "cn": "LDAPtestUSER3"})
2108 except LdbError, (num, _):
2109 self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
2112 ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser2,cn=users," + self.base_dn)
2114 # ensure we cannot rename it twice
2116 ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn,
2117 "cn=ldaptestuser2,cn=users," + self.base_dn)
2119 except LdbError, (num, _):
2120 self.assertEquals(num, ERR_NO_SUCH_OBJECT)
2122 # ensure can now use that name
2123 ldb.add({"dn": "cn=ldaptestuser3,cn=users," + self.base_dn,
2124 "objectClass": ["person", "user"],
2125 "cn": "LDAPtestUSER3"})
2127 # ensure we now cannot rename
2129 ldb.rename("cn=ldaptestuser2,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=users," + self.base_dn)
2131 except LdbError, (num, _):
2132 self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
2134 ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=configuration," + self.base_dn)
2136 except LdbError, (num, _):
2137 self.assertTrue(num in (71, 64))
2139 ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser5,cn=users," + self.base_dn)
2141 ldb.delete("cn=ldaptestuser5,cn=users," + self.base_dn)
2143 self.delete_force(ldb, "cn=ldaptestgroup2,cn=users," + self.base_dn)
2145 ldb.rename("cn=ldaptestgroup,cn=users," + self.base_dn, "cn=ldaptestgroup2,cn=users," + self.base_dn)
2147 print "Testing subtree renames"
2149 ldb.add({"dn": "cn=ldaptestcontainer," + self.base_dn,
2150 "objectClass": "container"})
2152 ldb.add({"dn": "CN=ldaptestuser4,CN=ldaptestcontainer," + self.base_dn,
2153 "objectClass": ["person", "user"],
2154 "cn": "LDAPtestUSER4"})
2157 dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
2160 member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """
2161 member: cn=ldaptestcomputer,cn=computers,""" + self.base_dn + """
2162 member: cn=ldaptestuser2,cn=users,""" + self.base_dn + """
2165 print "Testing ldb.rename of cn=ldaptestcontainer," + self.base_dn + " to cn=ldaptestcontainer2," + self.base_dn
2166 ldb.rename("CN=ldaptestcontainer," + self.base_dn, "CN=ldaptestcontainer2," + self.base_dn)
2168 print "Testing ldb.search for (&(cn=ldaptestuser4)(objectClass=user))"
2169 res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))")
2170 self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser4)(objectClass=user))")
2172 print "Testing subtree ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + self.base_dn
2174 res = ldb.search("cn=ldaptestcontainer," + self.base_dn,
2175 expression="(&(cn=ldaptestuser4)(objectClass=user))",
2176 scope=SCOPE_SUBTREE)
2178 except LdbError, (num, _):
2179 self.assertEquals(num, ERR_NO_SUCH_OBJECT)
2181 print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + self.base_dn
2183 res = ldb.search("cn=ldaptestcontainer," + self.base_dn,
2184 expression="(&(cn=ldaptestuser4)(objectClass=user))", scope=SCOPE_ONELEVEL)
2186 except LdbError, (num, _):
2187 self.assertEquals(num, ERR_NO_SUCH_OBJECT)
2189 print "Testing ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in renamed container"
2190 res = ldb.search("cn=ldaptestcontainer2," + self.base_dn, expression="(&(cn=ldaptestuser4)(objectClass=user))", scope=SCOPE_SUBTREE)
2191 self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser4)(objectClass=user)) under cn=ldaptestcontainer2," + self.base_dn)
2193 self.assertEquals(str(res[0].dn), ("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn))
2194 self.assertEquals(res[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
2198 print "Testing ldb.search for (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group)) to check subtree renames and linked attributes"
2199 res = ldb.search(self.base_dn, expression="(&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group))", scope=SCOPE_SUBTREE)
2200 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?")
2202 print "Testing ldb.rename (into itself) of cn=ldaptestcontainer2," + self.base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer2," + self.base_dn
2204 ldb.rename("cn=ldaptestcontainer2," + self.base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer2," + self.base_dn)
2206 except LdbError, (num, _):
2207 self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
2209 print "Testing ldb.rename (into non-existent container) of cn=ldaptestcontainer2," + self.base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer3," + self.base_dn
2211 ldb.rename("cn=ldaptestcontainer2," + self.base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer3," + self.base_dn)
2213 except LdbError, (num, _):
2214 self.assertTrue(num in (ERR_UNWILLING_TO_PERFORM, ERR_OTHER))
2216 print "Testing delete (should fail, not a leaf node) of renamed cn=ldaptestcontainer2," + self.base_dn
2218 ldb.delete("cn=ldaptestcontainer2," + self.base_dn)
2220 except LdbError, (num, _):
2221 self.assertEquals(num, ERR_NOT_ALLOWED_ON_NON_LEAF)
2223 print "Testing base ldb.search for CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn
2224 res = ldb.search(expression="(objectclass=*)", base=("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn), scope=SCOPE_BASE)
2225 self.assertEquals(len(res), 1)
2226 res = ldb.search(expression="(cn=ldaptestuser40)", base=("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn), scope=SCOPE_BASE)
2227 self.assertEquals(len(res), 0)
2229 print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in cn=ldaptestcontainer2," + self.base_dn
2230 res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))", base=("cn=ldaptestcontainer2," + self.base_dn), scope=SCOPE_ONELEVEL)
2231 # FIXME: self.assertEquals(len(res), 0)
2233 print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in cn=ldaptestcontainer2," + self.base_dn
2234 res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))", base=("cn=ldaptestcontainer2," + self.base_dn), scope=SCOPE_SUBTREE)
2235 # FIXME: self.assertEquals(len(res), 0)
2237 print "Testing delete of subtree renamed "+("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn)
2238 ldb.delete(("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn))
2239 print "Testing delete of renamed cn=ldaptestcontainer2," + self.base_dn
2240 ldb.delete("cn=ldaptestcontainer2," + self.base_dn)
2242 ldb.add({"dn": "cn=ldaptestutf8user èùéìòà,cn=users," + self.base_dn, "objectClass": "user"})
2244 ldb.add({"dn": "cn=ldaptestutf8user2 èùéìòà,cn=users," + self.base_dn, "objectClass": "user"})
2246 print "Testing ldb.search for (&(cn=ldaptestuser)(objectClass=user))"
2247 res = ldb.search(expression="(&(cn=ldaptestuser)(objectClass=user))")
2248 self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser)(objectClass=user))")
2250 self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn))
2251 self.assertEquals(str(res[0]["cn"]), "ldaptestuser")
2252 self.assertEquals(str(res[0]["name"]), "ldaptestuser")
2253 self.assertEquals(set(res[0]["objectClass"]), set(["top", "person", "organizationalPerson", "user"]))
2254 self.assertTrue("objectGUID" in res[0])
2255 self.assertTrue("whenCreated" in res[0])
2256 self.assertEquals(str(res[0]["objectCategory"]), ("CN=Person,CN=Schema,CN=Configuration," + self.base_dn))
2257 self.assertEquals(int(res[0]["sAMAccountType"][0]), ATYPE_NORMAL_ACCOUNT)
2258 self.assertEquals(int(res[0]["userAccountControl"][0]), UF_NORMAL_ACCOUNT | UF_PASSWD_NOTREQD | UF_ACCOUNTDISABLE)
2259 self.assertEquals(res[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
2260 self.assertEquals(len(res[0]["memberOf"]), 1)
2262 print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + self.base_dn + "))"
2263 res2 = ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + self.base_dn + "))")
2264 self.assertEquals(len(res2), 1, "Could not find (&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + self.base_dn + "))")
2266 self.assertEquals(res[0].dn, res2[0].dn)
2268 print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon))"
2269 res3 = ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=PerSon))")
2270 self.assertEquals(len(res3), 1, "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)): matched %d" % len(res3))
2272 self.assertEquals(res[0].dn, res3[0].dn)
2274 if gc_ldb is not None:
2275 print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog"
2276 res3gc = gc_ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=PerSon))")
2277 self.assertEquals(len(res3gc), 1)
2279 self.assertEquals(res[0].dn, res3gc[0].dn)
2281 print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon)) in with 'phantom root' control"
2283 if gc_ldb is not None:
2284 res3control = gc_ldb.search(self.base_dn, expression="(&(cn=ldaptestuser)(objectCategory=PerSon))", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:2"])
2285 self.assertEquals(len(res3control), 1, "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog")
2287 self.assertEquals(res[0].dn, res3control[0].dn)
2289 ldb.delete(res[0].dn)
2291 print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectClass=user))"
2292 res = ldb.search(expression="(&(cn=ldaptestcomputer)(objectClass=user))")
2293 self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser)(objectClass=user))")
2295 self.assertEquals(str(res[0].dn), ("CN=ldaptestcomputer,CN=Computers," + self.base_dn))
2296 self.assertEquals(str(res[0]["cn"]), "ldaptestcomputer")
2297 self.assertEquals(str(res[0]["name"]), "ldaptestcomputer")
2298 self.assertEquals(set(res[0]["objectClass"]), set(["top", "person", "organizationalPerson", "user", "computer"]))
2299 self.assertTrue("objectGUID" in res[0])
2300 self.assertTrue("whenCreated" in res[0])
2301 self.assertEquals(str(res[0]["objectCategory"]), ("CN=Computer,CN=Schema,CN=Configuration," + self.base_dn))
2302 self.assertEquals(int(res[0]["primaryGroupID"][0]), 513)
2303 self.assertEquals(int(res[0]["sAMAccountType"][0]), ATYPE_NORMAL_ACCOUNT)
2304 self.assertEquals(int(res[0]["userAccountControl"][0]), UF_NORMAL_ACCOUNT | UF_PASSWD_NOTREQD | UF_ACCOUNTDISABLE)
2305 self.assertEquals(res[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
2306 self.assertEquals(len(res[0]["memberOf"]), 1)
2308 print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + self.base_dn + "))"
2309 res2 = ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + self.base_dn + "))")
2310 self.assertEquals(len(res2), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + self.base_dn + "))")
2312 self.assertEquals(res[0].dn, res2[0].dn)
2314 if gc_ldb is not None:
2315 print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + self.base_dn + ")) in Global Catlog"
2316 res2gc = gc_ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + self.base_dn + "))")
2317 self.assertEquals(len(res2gc), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + self.base_dn + ")) in Global Catlog")
2319 self.assertEquals(res[0].dn, res2gc[0].dn)
2321 print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER))"
2322 res3 = ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=compuTER))")
2323 self.assertEquals(len(res3), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER))")
2325 self.assertEquals(res[0].dn, res3[0].dn)
2327 if gc_ldb is not None:
2328 print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog"
2329 res3gc = gc_ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=compuTER))")
2330 self.assertEquals(len(res3gc), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog")
2332 self.assertEquals(res[0].dn, res3gc[0].dn)
2334 print "Testing ldb.search for (&(cn=ldaptestcomp*r)(objectCategory=compuTER))"
2335 res4 = ldb.search(expression="(&(cn=ldaptestcomp*r)(objectCategory=compuTER))")
2336 self.assertEquals(len(res4), 1, "Could not find (&(cn=ldaptestcomp*r)(objectCategory=compuTER))")
2338 self.assertEquals(res[0].dn, res4[0].dn)
2340 print "Testing ldb.search for (&(cn=ldaptestcomput*)(objectCategory=compuTER))"
2341 res5 = ldb.search(expression="(&(cn=ldaptestcomput*)(objectCategory=compuTER))")
2342 self.assertEquals(len(res5), 1, "Could not find (&(cn=ldaptestcomput*)(objectCategory=compuTER))")
2344 self.assertEquals(res[0].dn, res5[0].dn)
2346 print "Testing ldb.search for (&(cn=*daptestcomputer)(objectCategory=compuTER))"
2347 res6 = ldb.search(expression="(&(cn=*daptestcomputer)(objectCategory=compuTER))")
2348 self.assertEquals(len(res6), 1, "Could not find (&(cn=*daptestcomputer)(objectCategory=compuTER))")
2350 self.assertEquals(res[0].dn, res6[0].dn)
2352 ldb.delete("<GUID=" + ldb.schema_format_value("objectGUID", res[0]["objectGUID"][0]) + ">")
2354 print "Testing ldb.search for (&(cn=ldaptest2computer)(objectClass=user))"
2355 res = ldb.search(expression="(&(cn=ldaptest2computer)(objectClass=user))")
2356 self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptest2computer)(objectClass=user))")
2358 self.assertEquals(str(res[0].dn), "CN=ldaptest2computer,CN=Computers," + self.base_dn)
2359 self.assertEquals(str(res[0]["cn"]), "ldaptest2computer")
2360 self.assertEquals(str(res[0]["name"]), "ldaptest2computer")
2361 self.assertEquals(list(res[0]["objectClass"]), ["top", "person", "organizationalPerson", "user", "computer"])
2362 self.assertTrue("objectGUID" in res[0])
2363 self.assertTrue("whenCreated" in res[0])
2364 self.assertEquals(res[0]["objectCategory"][0], "CN=Computer,CN=Schema,CN=Configuration," + self.base_dn)
2365 self.assertEquals(int(res[0]["sAMAccountType"][0]), ATYPE_WORKSTATION_TRUST)
2366 self.assertEquals(int(res[0]["userAccountControl"][0]), UF_WORKSTATION_TRUST_ACCOUNT)
2368 ldb.delete("<SID=" + ldb.schema_format_value("objectSID", res[0]["objectSID"][0]) + ">")
2370 attrs = ["cn", "name", "objectClass", "objectGUID", "objectSID", "whenCreated", "nTSecurityDescriptor", "memberOf", "allowedAttributes", "allowedAttributesEffective"]
2371 print "Testing ldb.search for (&(cn=ldaptestUSer2)(objectClass=user))"
2372 res_user = ldb.search(self.base_dn, expression="(&(cn=ldaptestUSer2)(objectClass=user))", scope=SCOPE_SUBTREE, attrs=attrs)
2373 self.assertEquals(len(res_user), 1, "Could not find (&(cn=ldaptestUSer2)(objectClass=user))")
2375 self.assertEquals(str(res_user[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
2376 self.assertEquals(str(res_user[0]["cn"]), "ldaptestuser2")
2377 self.assertEquals(str(res_user[0]["name"]), "ldaptestuser2")
2378 self.assertEquals(list(res_user[0]["objectClass"]), ["top", "person", "organizationalPerson", "user"])
2379 self.assertTrue("objectSid" in res_user[0])
2380 self.assertTrue("objectGUID" in res_user[0])
2381 self.assertTrue("whenCreated" in res_user[0])
2382 self.assertTrue("nTSecurityDescriptor" in res_user[0])
2383 self.assertTrue("allowedAttributes" in res_user[0])
2384 self.assertTrue("allowedAttributesEffective" in res_user[0])
2385 self.assertEquals(res_user[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
2387 ldaptestuser2_sid = res_user[0]["objectSid"][0]
2388 ldaptestuser2_guid = res_user[0]["objectGUID"][0]
2390 attrs = ["cn", "name", "objectClass", "objectGUID", "objectSID", "whenCreated", "nTSecurityDescriptor", "member", "allowedAttributes", "allowedAttributesEffective"]
2391 print "Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group))"
2392 res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs)
2393 self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))")
2395 self.assertEquals(str(res[0].dn), ("CN=ldaptestgroup2,CN=Users," + self.base_dn))
2396 self.assertEquals(str(res[0]["cn"]), "ldaptestgroup2")
2397 self.assertEquals(str(res[0]["name"]), "ldaptestgroup2")
2398 self.assertEquals(list(res[0]["objectClass"]), ["top", "group"])
2399 self.assertTrue("objectGUID" in res[0])
2400 self.assertTrue("objectSid" in res[0])
2401 self.assertTrue("whenCreated" in res[0])
2402 self.assertTrue("nTSecurityDescriptor" in res[0])
2403 self.assertTrue("allowedAttributes" in res[0])
2404 self.assertTrue("allowedAttributesEffective" in res[0])
2406 for m in res[0]["member"]:
2407 memberUP.append(m.upper())
2408 self.assertTrue(("CN=ldaptestuser2,CN=Users," + self.base_dn).upper() in memberUP)
2410 res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs, controls=["extended_dn:1:1"])
2411 self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))")
2413 print res[0]["member"]
2415 for m in res[0]["member"]:
2416 memberUP.append(m.upper())
2417 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()
2419 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)
2421 print "Quicktest for linked attributes"
2423 dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
2426 member: CN=ldaptestuser2,CN=Users,""" + self.base_dn + """
2427 member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
2431 dn: <GUID=""" + ldb.schema_format_value("objectGUID", res[0]["objectGUID"][0]) + """>
2434 member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
2438 dn: <SID=""" + ldb.schema_format_value("objectSid", res[0]["objectSid"][0]) + """>
2444 dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
2447 member: <GUID=""" + ldb.schema_format_value("objectGUID", res[0]["objectGUID"][0]) + """>
2448 member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
2452 dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
2458 dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
2461 member: <SID=""" + ldb.schema_format_value("objectSid", res_user[0]["objectSid"][0]) + """>
2462 member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
2466 dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
2469 member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """
2472 res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs)
2473 self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))")
2475 self.assertEquals(str(res[0].dn), ("CN=ldaptestgroup2,CN=Users," + self.base_dn))
2476 self.assertEquals(res[0]["member"][0], ("CN=ldaptestuser2,CN=Users," + self.base_dn))
2477 self.assertEquals(len(res[0]["member"]), 1)
2479 ldb.delete(("CN=ldaptestuser2,CN=Users," + self.base_dn))
2483 attrs = ["cn", "name", "objectClass", "objectGUID", "whenCreated", "nTSecurityDescriptor", "member"]
2484 print "Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete"
2485 res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs)
2486 self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete")
2488 self.assertEquals(str(res[0].dn), ("CN=ldaptestgroup2,CN=Users," + self.base_dn))
2489 self.assertTrue("member" not in res[0])
2491 print "Testing ldb.search for (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))"
2492 # TODO UTF8 users don't seem to work fully anymore
2493 # res = ldb.search(expression="(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
2494 res = ldb.search(expression="(&(cn=ldaptestutf8user èùéìòà)(objectclass=user))")
2495 self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
2497 self.assertEquals(str(res[0].dn), ("CN=ldaptestutf8user èùéìòà,CN=Users," + self.base_dn))
2498 self.assertEquals(str(res[0]["cn"]), "ldaptestutf8user èùéìòà")
2499 self.assertEquals(str(res[0]["name"]), "ldaptestutf8user èùéìòà")
2500 self.assertEquals(list(res[0]["objectClass"]), ["top", "person", "organizationalPerson", "user"])
2501 self.assertTrue("objectGUID" in res[0])
2502 self.assertTrue("whenCreated" in res[0])
2504 ldb.delete(res[0].dn)
2506 print "Testing ldb.search for (&(cn=ldaptestutf8user2*)(objectClass=user))"
2507 res = ldb.search(expression="(&(cn=ldaptestutf8user2*)(objectClass=user))")
2508 self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestutf8user2*)(objectClass=user))")
2510 ldb.delete(res[0].dn)
2512 ldb.delete(("CN=ldaptestgroup2,CN=Users," + self.base_dn))
2514 print "Testing ldb.search for (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))"
2515 # TODO UTF8 users don't seem to work fully anymore
2516 # res = ldb.search(expression="(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
2517 # self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
2519 print "Testing that we can't get at the configuration DN from the main search base"
2520 res = ldb.search(self.base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"])
2521 self.assertEquals(len(res), 0)
2523 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"
2524 res = ldb.search(self.base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:2"])
2525 self.assertTrue(len(res) > 0)
2527 if gc_ldb is not None:
2528 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"
2530 res = gc_ldb.search(self.base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:0"])
2531 self.assertTrue(len(res) > 0)
2533 print "Testing that we do find configuration elements in the global catlog"
2534 res = gc_ldb.search(self.base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"])
2535 self.assertTrue(len(res) > 0)
2537 print "Testing that we do find configuration elements and user elements at the same time"
2538 res = gc_ldb.search(self.base_dn, expression="(|(objectClass=crossRef)(objectClass=person))", scope=SCOPE_SUBTREE, attrs=["cn"])
2539 self.assertTrue(len(res) > 0)
2541 print "Testing that we do find configuration elements in the global catlog, with the configuration basedn"
2542 res = gc_ldb.search(self.configuration_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"])
2543 self.assertTrue(len(res) > 0)
2545 print "Testing that we can get at the configuration DN on the main LDAP port"
2546 res = ldb.search(self.configuration_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"])
2547 self.assertTrue(len(res) > 0)
2549 print "Testing objectCategory canonacolisation"
2550 res = ldb.search(self.configuration_dn, expression="objectCategory=ntDsDSA", scope=SCOPE_SUBTREE, attrs=["cn"])
2551 self.assertTrue(len(res) > 0, "Didn't find any records with objectCategory=ntDsDSA")
2552 self.assertTrue(len(res) != 0)
2554 res = ldb.search(self.configuration_dn, expression="objectCategory=CN=ntDs-DSA," + self.schema_dn, scope=SCOPE_SUBTREE, attrs=["cn"])
2555 self.assertTrue(len(res) > 0, "Didn't find any records with objectCategory=CN=ntDs-DSA," + self.schema_dn)
2556 self.assertTrue(len(res) != 0)
2558 print "Testing objectClass attribute order on "+ self.base_dn
2559 res = ldb.search(expression="objectClass=domain", base=self.base_dn,
2560 scope=SCOPE_BASE, attrs=["objectClass"])
2561 self.assertEquals(len(res), 1)
2563 self.assertEquals(list(res[0]["objectClass"]), ["top", "domain", "domainDNS"])
2567 print "Testing ldb.search for objectCategory=person"
2568 res = ldb.search(self.base_dn, expression="objectCategory=person", scope=SCOPE_SUBTREE, attrs=["cn"])
2569 self.assertTrue(len(res) > 0)
2571 print "Testing ldb.search for objectCategory=person with domain scope control"
2572 res = ldb.search(self.base_dn, expression="objectCategory=person", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"])
2573 self.assertTrue(len(res) > 0)
2575 print "Testing ldb.search for objectCategory=user"
2576 res = ldb.search(self.base_dn, expression="objectCategory=user", scope=SCOPE_SUBTREE, attrs=["cn"])
2577 self.assertTrue(len(res) > 0)
2579 print "Testing ldb.search for objectCategory=user with domain scope control"
2580 res = ldb.search(self.base_dn, expression="objectCategory=user", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"])
2581 self.assertTrue(len(res) > 0)
2583 print "Testing ldb.search for objectCategory=group"
2584 res = ldb.search(self.base_dn, expression="objectCategory=group", scope=SCOPE_SUBTREE, attrs=["cn"])
2585 self.assertTrue(len(res) > 0)
2587 print "Testing ldb.search for objectCategory=group with domain scope control"
2588 res = ldb.search(self.base_dn, expression="objectCategory=group", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"])
2589 self.assertTrue(len(res) > 0)
2591 print "Testing creating a user with the posixAccount objectClass"
2592 self.ldb.add_ldif("""dn: cn=posixuser,CN=Users,%s
2595 objectClass: posixAccount
2597 objectClass: organizationalPerson
2603 homeDirectory: /home/posixuser
2604 loginShell: /bin/bash
2605 gecos: Posix User;;;
2606 description: A POSIX user"""% (self.base_dn))
2608 print "Testing removing the posixAccount objectClass from an existing user"
2609 self.ldb.modify_ldif("""dn: cn=posixuser,CN=Users,%s
2612 objectClass: posixAccount"""% (self.base_dn))
2614 print "Testing adding the posixAccount objectClass to an existing user"
2615 self.ldb.modify_ldif("""dn: cn=posixuser,CN=Users,%s
2618 objectClass: posixAccount"""% (self.base_dn))
2620 self.delete_force(self.ldb, "cn=posixuser,cn=users," + self.base_dn)
2621 self.delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
2622 self.delete_force(self.ldb, "cn=ldaptestuser2,cn=users," + self.base_dn)
2623 self.delete_force(self.ldb, "cn=ldaptestuser3,cn=users," + self.base_dn)
2624 self.delete_force(self.ldb, "cn=ldaptestuser4,cn=ldaptestcontainer," + self.base_dn)
2625 self.delete_force(self.ldb, "cn=ldaptestuser4,cn=ldaptestcontainer2," + self.base_dn)
2626 self.delete_force(self.ldb, "cn=ldaptestuser5,cn=users," + self.base_dn)
2627 self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
2628 self.delete_force(self.ldb, "cn=ldaptestgroup2,cn=users," + self.base_dn)
2629 self.delete_force(self.ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
2630 self.delete_force(self.ldb, "cn=ldaptest2computer,cn=computers," + self.base_dn)
2631 self.delete_force(self.ldb, "cn=ldaptestcomputer3,cn=computers," + self.base_dn)
2632 self.delete_force(self.ldb, "cn=ldaptestutf8user èùéìòà,cn=users," + self.base_dn)
2633 self.delete_force(self.ldb, "cn=ldaptestutf8user2 èùéìòà,cn=users," + self.base_dn)
2634 self.delete_force(self.ldb, "cn=ldaptestcontainer," + self.base_dn)
2635 self.delete_force(self.ldb, "cn=ldaptestcontainer2," + self.base_dn)
2637 def test_security_descriptor_add(self):
2638 """ Testing ldb.add_ldif() for nTSecurityDescriptor """
2639 user_name = "testdescriptoruser1"
2640 user_dn = "CN=%s,CN=Users,%s" % (user_name, self.base_dn)
2642 # Test add_ldif() with SDDL security descriptor input
2644 self.delete_force(self.ldb, user_dn)
2646 sddl = "O:DUG:DUD:PAI(A;;RPWP;;;AU)S:PAI"
2647 self.ldb.add_ldif("""
2648 dn: """ + user_dn + """
2650 sAMAccountName: """ + user_name + """
2651 nTSecurityDescriptor: """ + sddl)
2652 res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2653 desc = res[0]["nTSecurityDescriptor"][0]
2654 desc = ndr_unpack( security.descriptor, desc )
2655 desc_sddl = desc.as_sddl( self.domain_sid )
2656 self.assertEqual(desc_sddl, sddl)
2658 self.delete_force(self.ldb, user_dn)
2660 # Test add_ldif() with BASE64 security descriptor
2663 sddl = "O:DUG:DUD:PAI(A;;RPWP;;;AU)S:PAI"
2664 desc = security.descriptor.from_sddl(sddl, self.domain_sid)
2665 desc_binary = ndr_pack(desc)
2666 desc_base64 = base64.b64encode(desc_binary)
2667 self.ldb.add_ldif("""
2668 dn: """ + user_dn + """
2670 sAMAccountName: """ + user_name + """
2671 nTSecurityDescriptor:: """ + desc_base64)
2672 res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2673 desc = res[0]["nTSecurityDescriptor"][0]
2674 desc = ndr_unpack(security.descriptor, desc)
2675 desc_sddl = desc.as_sddl(self.domain_sid)
2676 self.assertEqual(desc_sddl, sddl)
2678 self.delete_force(self.ldb, user_dn)
2680 def test_security_descriptor_add_neg(self):
2681 """Test add_ldif() with BASE64 security descriptor input using WRONG domain SID
2684 user_name = "testdescriptoruser1"
2685 user_dn = "CN=%s,CN=Users,%s" % (user_name, self.base_dn)
2686 self.delete_force(self.ldb, user_dn)
2688 sddl = "O:DUG:DUD:PAI(A;;RPWP;;;AU)S:PAI"
2689 desc = security.descriptor.from_sddl(sddl, security.dom_sid('S-1-5-21'))
2690 desc_base64 = base64.b64encode( ndr_pack(desc) )
2691 self.ldb.add_ldif("""
2692 dn: """ + user_dn + """
2694 sAMAccountName: """ + user_name + """
2695 nTSecurityDescriptor:: """ + desc_base64)
2696 res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2697 self.assertTrue("nTSecurityDescriptor" in res[0])
2699 self.delete_force(self.ldb, user_dn)
2701 def test_security_descriptor_modify(self):
2702 """ Testing ldb.modify_ldif() for nTSecurityDescriptor """
2703 user_name = "testdescriptoruser2"
2704 user_dn = "CN=%s,CN=Users,%s" % (user_name, self.base_dn)
2706 # Delete user object and test modify_ldif() with SDDL security descriptor input
2707 # Add ACE to the original descriptor test
2710 self.delete_force(self.ldb, user_dn)
2711 self.ldb.add_ldif("""
2712 dn: """ + user_dn + """
2714 sAMAccountName: """ + user_name)
2716 res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2717 desc = res[0]["nTSecurityDescriptor"][0]
2718 desc = ndr_unpack(security.descriptor, desc)
2719 desc_sddl = desc.as_sddl(self.domain_sid)
2720 sddl = desc_sddl[:desc_sddl.find("(")] + "(A;;RPWP;;;AU)" + desc_sddl[desc_sddl.find("("):]
2722 dn: """ + user_dn + """
2724 replace: nTSecurityDescriptor
2725 nTSecurityDescriptor: """ + sddl
2726 self.ldb.modify_ldif(mod)
2727 # Read modified descriptor
2728 res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2729 desc = res[0]["nTSecurityDescriptor"][0]
2730 desc = ndr_unpack(security.descriptor, desc)
2731 desc_sddl = desc.as_sddl(self.domain_sid)
2732 self.assertEqual(desc_sddl, sddl)
2734 self.delete_force(self.ldb, user_dn)
2736 # Test modify_ldif() with SDDL security descriptor input
2737 # New desctiptor test
2740 self.ldb.add_ldif("""
2741 dn: """ + user_dn + """
2743 sAMAccountName: """ + user_name)
2745 sddl = "O:DUG:DUD:PAI(A;;RPWP;;;AU)S:PAI"
2747 dn: """ + user_dn + """
2749 replace: nTSecurityDescriptor
2750 nTSecurityDescriptor: """ + sddl
2751 self.ldb.modify_ldif(mod)
2752 # Read modified descriptor
2753 res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2754 desc = res[0]["nTSecurityDescriptor"][0]
2755 desc = ndr_unpack(security.descriptor, desc)
2756 desc_sddl = desc.as_sddl(self.domain_sid)
2757 self.assertEqual(desc_sddl, sddl)
2759 self.delete_force(self.ldb, user_dn)
2761 # Test modify_ldif() with BASE64 security descriptor input
2762 # Add ACE to the original descriptor test
2765 self.ldb.add_ldif("""
2766 dn: """ + user_dn + """
2768 sAMAccountName: """ + user_name)
2770 res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2771 desc = res[0]["nTSecurityDescriptor"][0]
2772 desc = ndr_unpack(security.descriptor, desc)
2773 desc_sddl = desc.as_sddl(self.domain_sid)
2774 sddl = desc_sddl[:desc_sddl.find("(")] + "(A;;RPWP;;;AU)" + desc_sddl[desc_sddl.find("("):]
2775 desc = security.descriptor.from_sddl(sddl, self.domain_sid)
2776 desc_base64 = base64.b64encode(ndr_pack(desc))
2778 dn: """ + user_dn + """
2780 replace: nTSecurityDescriptor
2781 nTSecurityDescriptor:: """ + desc_base64
2782 self.ldb.modify_ldif(mod)
2783 # Read modified descriptor
2784 res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2785 desc = res[0]["nTSecurityDescriptor"][0]
2786 desc = ndr_unpack(security.descriptor, desc)
2787 desc_sddl = desc.as_sddl(self.domain_sid)
2788 self.assertEqual(desc_sddl, sddl)
2790 self.delete_force(self.ldb, user_dn)
2792 # Test modify_ldif() with BASE64 security descriptor input
2793 # New descriptor test
2796 self.delete_force(self.ldb, user_dn)
2797 self.ldb.add_ldif("""
2798 dn: """ + user_dn + """
2800 sAMAccountName: """ + user_name)
2802 sddl = "O:DUG:DUD:PAI(A;;RPWP;;;AU)S:PAI"
2803 desc = security.descriptor.from_sddl(sddl, self.domain_sid)
2804 desc_base64 = base64.b64encode(ndr_pack(desc))
2806 dn: """ + user_dn + """
2808 replace: nTSecurityDescriptor
2809 nTSecurityDescriptor:: """ + desc_base64
2810 self.ldb.modify_ldif(mod)
2811 # Read modified descriptor
2812 res = self.ldb.search(base=user_dn, attrs=["nTSecurityDescriptor"])
2813 desc = res[0]["nTSecurityDescriptor"][0]
2814 desc = ndr_unpack(security.descriptor, desc)
2815 desc_sddl = desc.as_sddl(self.domain_sid)
2816 self.assertEqual(desc_sddl, sddl)
2818 self.delete_force(self.ldb, user_dn)
2821 class BaseDnTests(unittest.TestCase):
2824 super(BaseDnTests, self).setUp()
2827 def test_rootdse_attrs(self):
2828 """Testing for all rootDSE attributes"""
2829 res = self.ldb.search(scope=SCOPE_BASE, attrs=[])
2830 self.assertEquals(len(res), 1)
2832 def test_highestcommittedusn(self):
2833 """Testing for highestCommittedUSN"""
2834 res = self.ldb.search("", scope=SCOPE_BASE, attrs=["highestCommittedUSN"])
2835 self.assertEquals(len(res), 1)
2836 self.assertTrue(int(res[0]["highestCommittedUSN"][0]) != 0)
2838 def test_netlogon(self):
2839 """Testing for netlogon via LDAP"""
2840 res = self.ldb.search("", scope=SCOPE_BASE, attrs=["netlogon"])
2841 self.assertEquals(len(res), 0)
2843 def test_netlogon_highestcommitted_usn(self):
2844 """Testing for netlogon and highestCommittedUSN via LDAP"""
2845 res = self.ldb.search("", scope=SCOPE_BASE,
2846 attrs=["netlogon", "highestCommittedUSN"])
2847 self.assertEquals(len(res), 0)
2849 def test_namingContexts(self):
2850 """Testing for namingContexts in rootDSE"""
2851 res = self.ldb.search("", scope=SCOPE_BASE,
2852 attrs=["namingContexts", "defaultNamingContext", "schemaNamingContext", "configurationNamingContext"])
2853 self.assertEquals(len(res), 1)
2856 for nc in res[0]["namingContexts"]:
2857 self.assertTrue(nc not in ncs)
2860 self.assertTrue(res[0]["defaultNamingContext"][0] in ncs)
2861 self.assertTrue(res[0]["configurationNamingContext"][0] in ncs)
2862 self.assertTrue(res[0]["schemaNamingContext"][0] in ncs)
2865 if not "://" in host:
2866 if os.path.isfile(host):
2867 host = "tdb://%s" % host
2869 host = "ldap://%s" % host
2871 ldb = Ldb(host, credentials=creds, session_info=system_session(), lp=lp)
2872 if not "tdb://" in host:
2873 gc_ldb = Ldb("%s:3268" % host, credentials=creds,
2874 session_info=system_session(), lp=lp)
2878 runner = SubunitTestRunner()
2880 if not runner.run(unittest.makeSuite(BaseDnTests)).wasSuccessful():
2882 if not runner.run(unittest.makeSuite(BasicTests)).wasSuccessful():