Debian Codegraph @

lib/ldb-samba/tests/match_rules.py

raw
1 #!/usr/bin/env python3
2
3 import optparse
4 import sys
5 import os
6 import samba
7 import samba.getopt as options
8
9 from samba.tests.subunitrun import SubunitOptions, TestProgram
10
11 from samba.samdb import SamDB
12 from samba.auth import system_session
13 from ldb import Message, MessageElement, Dn, LdbError
14 from ldb import FLAG_MOD_ADD, FLAG_MOD_REPLACE, FLAG_MOD_DELETE
15 from ldb import SCOPE_BASE, SCOPE_SUBTREE, SCOPE_ONELEVEL
16
17 # TODO I'm ignoring case in these tests for now.
18 # This should be fixed to work inline with Windows.
19 # The literal strings are in the case Windows uses.
20 # Windows appear to preserve casing of the RDN and uppercase the other keys.
21
22
23 class MatchRulesTestsBase(samba.tests.TestCase):
24 def setUp(self):
25 super().setUp()
26 self.lp = self.sambaopts.get_loadparm()
27 self.creds = self.credopts.get_credentials(self.lp)
28
29 self.ldb = SamDB(self.host, credentials=self.creds,
30 session_info=system_session(self.lp),
31 lp=self.lp)
32 self.base_dn = self.ldb.domain_dn()
33 self.ou_rdn = "OU=matchrulestest"
34 self.ou = self.ou_rdn + "," + self.base_dn
35 self.ou_users = "OU=users,%s" % self.ou
36 self.ou_groups = "OU=groups,%s" % self.ou
37 self.ou_computers = "OU=computers,%s" % self.ou
38
39 try:
40 self.ldb.delete(self.ou, ["tree_delete:1"])
41 except LdbError as e:
42 pass
43
44 # Add a organizational unit to create objects
45 self.ldb.add({
46 "dn": self.ou,
47 "objectclass": "organizationalUnit"})
48
49 self.addCleanup(self.ldb.delete, self.ou, controls=['tree_delete:0'])
50
51
52 # Add the following OU hierarchy and set otherWellKnownObjects,
53 # which has BinaryDN syntax:
54 #
55 # o1
56 # |--> o2
57 # | |--> o3
58 # | | |-->o4
59
60 self.ldb.add({
61 "dn": "OU=o1,%s" % self.ou,
62 "objectclass": "organizationalUnit"})
63 self.ldb.add({
64 "dn": "OU=o2,OU=o1,%s" % self.ou,
65 "objectclass": "organizationalUnit"})
66 self.ldb.add({
67 "dn": "OU=o3,OU=o2,OU=o1,%s" % self.ou,
68 "objectclass": "organizationalUnit"})
69 self.ldb.add({
70 "dn": "OU=o4,OU=o3,OU=o2,OU=o1,%s" % self.ou,
71 "objectclass": "organizationalUnit"})
72
73 m = Message()
74 m.dn = Dn(self.ldb, self.ou)
75 m["otherWellKnownObjects"] = MessageElement("B:32:00000000000000000000000000000001:OU=o1,%s" % self.ou,
76 FLAG_MOD_ADD, "otherWellKnownObjects")
77 self.ldb.modify(m)
78
79 m = Message()
80 m.dn = Dn(self.ldb, "OU=o1,%s" % self.ou)
81 m["otherWellKnownObjects"] = MessageElement("B:32:00000000000000000000000000000002:OU=o2,OU=o1,%s" % self.ou,
82 FLAG_MOD_ADD, "otherWellKnownObjects")
83 self.ldb.modify(m)
84
85 m = Message()
86 m.dn = Dn(self.ldb, "OU=o2,OU=o1,%s" % self.ou)
87 m["otherWellKnownObjects"] = MessageElement("B:32:00000000000000000000000000000003:OU=o3,OU=o2,OU=o1,%s" % self.ou,
88 FLAG_MOD_ADD, "otherWellKnownObjects")
89 self.ldb.modify(m)
90
91 m = Message()
92 m.dn = Dn(self.ldb, "OU=o3,OU=o2,OU=o1,%s" % self.ou)
93 m["otherWellKnownObjects"] = MessageElement("B:32:00000000000000000000000000000004:OU=o4,OU=o3,OU=o2,OU=o1,%s" % self.ou,
94 FLAG_MOD_ADD, "otherWellKnownObjects")
95 self.ldb.modify(m)
96
97 # Create OU for users and groups
98 self.ldb.add({
99 "dn": self.ou_users,
100 "objectclass": "organizationalUnit"})
101 self.ldb.add({
102 "dn": self.ou_groups,
103 "objectclass": "organizationalUnit"})
104 self.ldb.add({
105 "dn": self.ou_computers,
106 "objectclass": "organizationalUnit"})
107
108 # Add four groups
109 self.ldb.add({
110 "dn": "cn=g1,%s" % self.ou_groups,
111 "objectclass": "group"})
112 self.ldb.add({
113 "dn": "cn=g2,%s" % self.ou_groups,
114 "objectclass": "group"})
115 self.ldb.add({
116 "dn": "cn=g4,%s" % self.ou_groups,
117 "objectclass": "group"})
118 self.ldb.add({
119 "dn": "cn=g3,%s" % self.ou_groups,
120 "objectclass": "group"})
121
122 # Add four users
123 self.ldb.add({
124 "dn": "cn=u1,%s" % self.ou_users,
125 "objectclass": "user"})
126 self.ldb.add({
127 "dn": "cn=u2,%s" % self.ou_users,
128 "objectclass": "user"})
129 self.ldb.add({
130 "dn": "cn=u3,%s" % self.ou_users,
131 "objectclass": "user"})
132 self.ldb.add({
133 "dn": "cn=u4,%s" % self.ou_users,
134 "objectclass": "user"})
135
136 # Add computers to test Object(DN-Binary) syntax
137 self.ldb.add({
138 "dn": "cn=c1,%s" % self.ou_computers,
139 "objectclass": "computer",
140 "dNSHostName": "c1.%s" % self.lp.get("realm").lower(),
141 "servicePrincipalName": ["HOST/c1"],
142 "sAMAccountName": "c1$",
143 "userAccountControl": "83890178"})
144
145 self.ldb.add({
146 "dn": "cn=c2,%s" % self.ou_computers,
147 "objectclass": "computer",
148 "dNSHostName": "c2.%s" % self.lp.get("realm").lower(),
149 "servicePrincipalName": ["HOST/c2"],
150 "sAMAccountName": "c2$",
151 "userAccountControl": "83890178"})
152
153 self.ldb.add({
154 "dn": "cn=c3,%s" % self.ou_computers,
155 "objectclass": "computer",
156 "dNSHostName": "c3.%s" % self.lp.get("realm").lower(),
157 "servicePrincipalName": ["HOST/c3"],
158 "sAMAccountName": "c3$",
159 "userAccountControl": "83890178"})
160
161 # Create the following hierarchy:
162 # g4
163 # |--> u4
164 # |--> g3
165 # | |--> u3
166 # | |--> g2
167 # | | |--> u2
168 # | | |--> g1
169 # | | | |--> u1
170
171 # u1 member of g1
172 m = Message()
173 m.dn = Dn(self.ldb, "CN=g1,%s" % self.ou_groups)
174 m["member"] = MessageElement("CN=u1,%s" % self.ou_users,
175 FLAG_MOD_ADD, "member")
176 self.ldb.modify(m)
177
178 # u2 member of g2
179 m = Message()
180 m.dn = Dn(self.ldb, "CN=g2,%s" % self.ou_groups)
181 m["member"] = MessageElement("cn=u2,%s" % self.ou_users,
182 FLAG_MOD_ADD, "member")
183 self.ldb.modify(m)
184
185 # u3 member of g3
186 m = Message()
187 m.dn = Dn(self.ldb, "cn=g3,%s" % self.ou_groups)
188 m["member"] = MessageElement("CN=u3,%s" % self.ou_users,
189 FLAG_MOD_ADD, "member")
190 self.ldb.modify(m)
191
192 # u4 member of g4
193 m = Message()
194 m.dn = Dn(self.ldb, "cn=g4,%s" % self.ou_groups)
195 m["member"] = MessageElement("cn=u4,%s" % self.ou_users,
196 FLAG_MOD_ADD, "member")
197 self.ldb.modify(m)
198
199 # g3 member of g4
200 m = Message()
201 m.dn = Dn(self.ldb, "CN=g4,%s" % self.ou_groups)
202 m["member"] = MessageElement("cn=g3,%s" % self.ou_groups,
203 FLAG_MOD_ADD, "member")
204 self.ldb.modify(m)
205
206 # g2 member of g3
207 m = Message()
208 m.dn = Dn(self.ldb, "cn=g3,%s" % self.ou_groups)
209 m["member"] = MessageElement("CN=g2,%s" % self.ou_groups,
210 FLAG_MOD_ADD, "member")
211 self.ldb.modify(m)
212
213 # g1 member of g2
214 m = Message()
215 m.dn = Dn(self.ldb, "cn=g2,%s" % self.ou_groups)
216 m["member"] = MessageElement("cn=g1,%s" % self.ou_groups,
217 FLAG_MOD_ADD, "member")
218 self.ldb.modify(m)
219
220 # Add a couple of ms-Exch-Configuration-Container to test forward-link
221 # attributes without backward link (addressBookRoots2)
222 # e1
223 # |--> e2
224 # | |--> c1
225 self.ldb.add({
226 "dn": "cn=e1,%s" % self.ou,
227 "objectclass": "msExchConfigurationContainer"})
228 self.ldb.add({
229 "dn": "cn=e2,%s" % self.ou,
230 "objectclass": "msExchConfigurationContainer"})
231
232 m = Message()
233 m.dn = Dn(self.ldb, "cn=e2,%s" % self.ou)
234 m["e1"] = MessageElement("cn=c1,%s" % self.ou_computers,
235 FLAG_MOD_ADD, "addressBookRoots2")
236 self.ldb.modify(m)
237
238 m = Message()
239 m.dn = Dn(self.ldb, "cn=e1,%s" % self.ou)
240 m["e1"] = MessageElement("cn=e2,%s" % self.ou,
241 FLAG_MOD_ADD, "addressBookRoots2")
242 self.ldb.modify(m)
243
244
245
246 class MatchRulesTests(MatchRulesTestsBase):
247 def setUp(self):
248 self.sambaopts = sambaopts
249 self.credopts = credopts
250 self.host = host
251 super().setUp()
252
253 # The msDS-RevealedUsers is owned by system and cannot be modified
254 # directly. Set the schemaUpgradeInProgress flag as workaround
255 # and create this hierarchy:
256 # ou=computers
257 # |-> c1
258 # | |->c2
259 # | | |->u1
260
261 #
262 # While appropriate for this test, this is NOT a good practice
263 # in general. This is only done here because the alternative
264 # is to make a schema modification.
265 #
266 # IF/WHEN Samba protects this attribute better, this
267 # particular part of the test can be removed, as the same code
268 # is covered by the addressBookRoots2 case well enough.
269 #
270 m = Message()
271 m.dn = Dn(self.ldb, "")
272 m["e1"] = MessageElement("1", FLAG_MOD_REPLACE, "schemaUpgradeInProgress")
273 self.ldb.modify(m)
274
275 m = Message()
276 m.dn = Dn(self.ldb, "cn=c2,%s" % self.ou_computers)
277 m["e1"] = MessageElement("B:8:01010101:cn=c3,%s" % self.ou_computers,
278 FLAG_MOD_ADD, "msDS-RevealedUsers")
279 self.ldb.modify(m)
280
281 m = Message()
282 m.dn = Dn(self.ldb, "cn=c1,%s" % self.ou_computers)
283 m["e1"] = MessageElement("B:8:01010101:cn=c2,%s" % self.ou_computers,
284 FLAG_MOD_ADD, "msDS-RevealedUsers")
285 self.ldb.modify(m)
286
287 m = Message()
288 m.dn = Dn(self.ldb, "")
289 m["e1"] = MessageElement("0", FLAG_MOD_REPLACE, "schemaUpgradeInProgress")
290 self.ldb.modify(m)
291
292
293 def test_u1_member_of_g4(self):
294 # Search without transitive match must return 0 results
295 res1 = self.ldb.search("cn=g4,%s" % self.ou_groups,
296 scope=SCOPE_BASE,
297 expression="member=cn=u1,%s" % self.ou_users)
298 self.assertEqual(len(res1), 0)
299
300 res1 = self.ldb.search("cn=u1,%s" % self.ou_users,
301 scope=SCOPE_BASE,
302 expression="memberOf=cn=g4,%s" % self.ou_groups)
303 self.assertEqual(len(res1), 0)
304
305 # Search with transitive match must return 1 results
306 res1 = self.ldb.search("cn=g4,%s" % self.ou_groups,
307 scope=SCOPE_BASE,
308 expression="member:1.2.840.113556.1.4.1941:=cn=u1,%s" % self.ou_users)
309 self.assertEqual(len(res1), 1)
310 self.assertEqual(str(res1[0].dn).lower(), ("CN=g4,%s" % self.ou_groups).lower())
311
312 res1 = self.ldb.search("cn=u1,%s" % self.ou_users,
313 scope=SCOPE_BASE,
314 expression="memberOf:1.2.840.113556.1.4.1941:=cn=g4,%s" % self.ou_groups)
315 self.assertEqual(len(res1), 1)
316 self.assertEqual(str(res1[0].dn).lower(), ("CN=u1,%s" % self.ou_users).lower())
317
318 def test_g1_member_of_g4(self):
319 # Search without transitive match must return 0 results
320 res1 = self.ldb.search("cn=g4,%s" % self.ou_groups,
321 scope=SCOPE_BASE,
322 expression="member=cn=g1,%s" % self.ou_groups)
323 self.assertEqual(len(res1), 0)
324
325 res1 = self.ldb.search("cn=g1,%s" % self.ou_groups,
326 scope=SCOPE_BASE,
327 expression="memberOf=cn=g4,%s" % self.ou_groups)
328 self.assertEqual(len(res1), 0)
329
330 # Search with transitive match must return 1 results
331 res1 = self.ldb.search("cn=g4,%s" % self.ou_groups,
332 scope=SCOPE_BASE,
333 expression="member:1.2.840.113556.1.4.1941:=cn=g1,%s" % self.ou_groups)
334 self.assertEqual(len(res1), 1)
335 self.assertEqual(str(res1[0].dn).lower(), ("CN=g4,%s" % self.ou_groups).lower())
336
337 res1 = self.ldb.search("cn=g1,%s" % self.ou_groups,
338 scope=SCOPE_BASE,
339 expression="memberOf:1.2.840.113556.1.4.1941:=cn=g4,%s" % self.ou_groups)
340 self.assertEqual(len(res1), 1)
341 self.assertEqual(str(res1[0].dn).lower(), ("CN=g1,%s" % self.ou_groups).lower())
342
343 def test_u1_groups(self):
344 res1 = self.ldb.search(self.ou_groups,
345 scope=SCOPE_SUBTREE,
346 expression="member=cn=u1,%s" % self.ou_users)
347 self.assertEqual(len(res1), 1)
348 self.assertEqual(str(res1[0].dn).lower(), ("CN=g1,%s" % self.ou_groups).lower())
349
350 res1 = self.ldb.search(self.ou_users,
351 scope=SCOPE_SUBTREE,
352 expression="member=cn=u1,%s" % self.ou_users)
353 self.assertEqual(len(res1), 0)
354
355 res1 = self.ldb.search(self.ou_groups,
356 scope=SCOPE_SUBTREE,
357 expression="member:1.2.840.113556.1.4.1941:=cn=u1,%s" % self.ou_users)
358 self.assertEqual(len(res1), 4)
359 dn_list = [str(res.dn).lower() for res in res1]
360 self.assertTrue(("CN=g1,%s" % self.ou_groups).lower() in dn_list)
361 self.assertTrue(("CN=g2,%s" % self.ou_groups).lower() in dn_list)
362 self.assertTrue(("CN=g3,%s" % self.ou_groups).lower() in dn_list)
363 self.assertTrue(("CN=g4,%s" % self.ou_groups).lower() in dn_list)
364
365 res1 = self.ldb.search(self.ou_users,
366 scope=SCOPE_SUBTREE,
367 expression="member:1.2.840.113556.1.4.1941:=cn=u1,%s" % self.ou_users)
368 self.assertEqual(len(res1), 0)
369
370 def test_u2_groups(self):
371 res1 = self.ldb.search(self.ou_groups,
372 scope=SCOPE_SUBTREE,
373 expression="member=cn=u2,%s" % self.ou_users)
374 self.assertEqual(len(res1), 1)
375 self.assertEqual(str(res1[0].dn).lower(), ("CN=g2,%s" % self.ou_groups).lower())
376
377 res1 = self.ldb.search(self.ou_users,
378 scope=SCOPE_SUBTREE,
379 expression="member=cn=u2,%s" % self.ou_users)
380 self.assertEqual(len(res1), 0)
381
382 res1 = self.ldb.search(self.ou_groups,
383 scope=SCOPE_SUBTREE,
384 expression="member:1.2.840.113556.1.4.1941:=cn=u2,%s" % self.ou_users)
385 self.assertEqual(len(res1), 3)
386 dn_list = [str(res.dn).lower() for res in res1]
387 self.assertTrue(("CN=g2,%s" % self.ou_groups).lower() in dn_list)
388 self.assertTrue(("CN=g3,%s" % self.ou_groups).lower() in dn_list)
389 self.assertTrue(("CN=g4,%s" % self.ou_groups).lower() in dn_list)
390
391 res1 = self.ldb.search(self.ou_users,
392 scope=SCOPE_SUBTREE,
393 expression="member:1.2.840.113556.1.4.1941:=cn=u2,%s" % self.ou_users)
394 self.assertEqual(len(res1), 0)
395
396 def test_u3_groups(self):
397 res1 = self.ldb.search(self.ou_groups,
398 scope=SCOPE_SUBTREE,
399 expression="member=cn=u3,%s" % self.ou_users)
400 self.assertEqual(len(res1), 1)
401 self.assertEqual(str(res1[0].dn).lower(), ("CN=g3,%s" % self.ou_groups).lower())
402
403 res1 = self.ldb.search(self.ou_users,
404 scope=SCOPE_SUBTREE,
405 expression="member=cn=u3,%s" % self.ou_users)
406 self.assertEqual(len(res1), 0)
407
408 res1 = self.ldb.search(self.ou_groups,
409 scope=SCOPE_SUBTREE,
410 expression="member:1.2.840.113556.1.4.1941:=cn=u3,%s" % self.ou_users)
411 self.assertEqual(len(res1), 2)
412 dn_list = [str(res.dn).lower() for res in res1]
413 self.assertTrue(("CN=g3,%s" % self.ou_groups).lower() in dn_list)
414 self.assertTrue(("CN=g4,%s" % self.ou_groups).lower() in dn_list)
415
416 res1 = self.ldb.search(self.ou_users,
417 scope=SCOPE_SUBTREE,
418 expression="member:1.2.840.113556.1.4.1941:=cn=u3,%s" % self.ou_users)
419 self.assertEqual(len(res1), 0)
420
421 def test_u4_groups(self):
422 res1 = self.ldb.search(self.ou_groups,
423 scope=SCOPE_SUBTREE,
424 expression="member=cn=u4,%s" % self.ou_users)
425 self.assertEqual(len(res1), 1)
426 self.assertEqual(str(res1[0].dn).lower(), ("CN=g4,%s" % self.ou_groups).lower())
427
428 res1 = self.ldb.search(self.ou_users,
429 scope=SCOPE_SUBTREE,
430 expression="member=cn=u4,%s" % self.ou_users)
431 self.assertEqual(len(res1), 0)
432
433 res1 = self.ldb.search(self.ou_groups,
434 scope=SCOPE_SUBTREE,
435 expression="member:1.2.840.113556.1.4.1941:=cn=u4,%s" % self.ou_users)
436 self.assertEqual(len(res1), 1)
437 self.assertEqual(str(res1[0].dn).lower(), ("CN=g4,%s" % self.ou_groups).lower())
438
439 res1 = self.ldb.search(self.ou_users,
440 scope=SCOPE_SUBTREE,
441 expression="member:1.2.840.113556.1.4.1941:=cn=u4,%s" % self.ou_users)
442 self.assertEqual(len(res1), 0)
443
444 def test_extended_dn_u1(self):
445 res1 = self.ldb.search("cn=u1,%s" % self.ou_users,
446 scope=SCOPE_BASE,
447 expression="objectClass=*",
448 attrs=['objectSid', 'objectGUID'])
449 self.assertEqual(len(res1), 1)
450 self.assertEqual(str(res1[0].dn).lower(), ("cn=u1,%s" % self.ou_users).lower())
451
452 sid = self.ldb.schema_format_value("objectSid", res1[0]["objectSid"][0]).decode('utf8')
453 guid = self.ldb.schema_format_value("objectGUID", res1[0]['objectGUID'][0]).decode('utf8')
454
455 res1 = self.ldb.search(self.ou_groups,
456 scope=SCOPE_SUBTREE,
457 expression="member=<SID=%s>" % sid)
458 self.assertEqual(len(res1), 1)
459 self.assertEqual(str(res1[0].dn).lower(), ("CN=g1,%s" % self.ou_groups).lower())
460
461 res1 = self.ldb.search(self.ou_groups,
462 scope=SCOPE_SUBTREE,
463 expression="member=<GUID=%s>" % guid)
464 self.assertEqual(len(res1), 1)
465 self.assertEqual(str(res1[0].dn).lower(), ("CN=g1,%s" % self.ou_groups).lower())
466
467 res1 = self.ldb.search(self.ou_groups,
468 scope=SCOPE_SUBTREE,
469 expression="member:1.2.840.113556.1.4.1941:=<SID=%s>" % sid)
470 self.assertEqual(len(res1), 4)
471 dn_list = [str(res.dn).lower() for res in res1]
472 self.assertTrue(("CN=g1,%s" % self.ou_groups).lower() in dn_list)
473 self.assertTrue(("CN=g2,%s" % self.ou_groups).lower() in dn_list)
474 self.assertTrue(("CN=g3,%s" % self.ou_groups).lower() in dn_list)
475 self.assertTrue(("CN=g4,%s" % self.ou_groups).lower() in dn_list)
476
477 res1 = self.ldb.search(self.ou_groups,
478 scope=SCOPE_ONELEVEL,
479 expression="member:1.2.840.113556.1.4.1941:=<SID=%s>" % sid)
480 self.assertEqual(len(res1), 4)
481 dn_list = [str(res.dn).lower() for res in res1]
482 self.assertTrue(("CN=g1,%s" % self.ou_groups).lower() in dn_list)
483 self.assertTrue(("CN=g2,%s" % self.ou_groups).lower() in dn_list)
484 self.assertTrue(("CN=g3,%s" % self.ou_groups).lower() in dn_list)
485 self.assertTrue(("CN=g4,%s" % self.ou_groups).lower() in dn_list)
486
487 res1 = self.ldb.search(self.ou_groups,
488 scope=SCOPE_SUBTREE,
489 expression="member:1.2.840.113556.1.4.1941:=<GUID=%s>" % guid)
490 self.assertEqual(len(res1), 4)
491 dn_list = [str(res.dn).lower() for res in res1]
492 self.assertTrue(("CN=g1,%s" % self.ou_groups).lower() in dn_list)
493 self.assertTrue(("CN=g2,%s" % self.ou_groups).lower() in dn_list)
494 self.assertTrue(("CN=g3,%s" % self.ou_groups).lower() in dn_list)
495 self.assertTrue(("CN=g4,%s" % self.ou_groups).lower() in dn_list)
496
497 res1 = self.ldb.search(self.ou_groups,
498 scope=SCOPE_ONELEVEL,
499 expression="member:1.2.840.113556.1.4.1941:=<GUID=%s>" % guid)
500 self.assertEqual(len(res1), 4)
501 dn_list = [str(res.dn).lower() for res in res1]
502 self.assertTrue(("CN=g1,%s" % self.ou_groups).lower() in dn_list)
503 self.assertTrue(("CN=g2,%s" % self.ou_groups).lower() in dn_list)
504 self.assertTrue(("CN=g3,%s" % self.ou_groups).lower() in dn_list)
505 self.assertTrue(("CN=g4,%s" % self.ou_groups).lower() in dn_list)
506
507 def test_extended_dn_u2(self):
508 res1 = self.ldb.search("cn=u2,%s" % self.ou_users,
509 scope=SCOPE_BASE,
510 expression="objectClass=*",
511 attrs=['objectSid', 'objectGUID'])
512 self.assertEqual(len(res1), 1)
513 self.assertEqual(str(res1[0].dn).lower(), ("cn=u2,%s" % self.ou_users).lower())
514
515 sid = self.ldb.schema_format_value("objectSid", res1[0]["objectSid"][0]).decode('utf8')
516 guid = self.ldb.schema_format_value("objectGUID", res1[0]['objectGUID'][0]).decode('utf8')
517
518 res1 = self.ldb.search(self.ou_groups,
519 scope=SCOPE_SUBTREE,
520 expression="member=<SID=%s>" % sid)
521 self.assertEqual(len(res1), 1)
522 self.assertEqual(str(res1[0].dn).lower(), ("CN=g2,%s" % self.ou_groups).lower())
523
524 res1 = self.ldb.search(self.ou_groups,
525 scope=SCOPE_SUBTREE,
526 expression="member=<GUID=%s>" % guid)
527 self.assertEqual(len(res1), 1)
528 self.assertEqual(str(res1[0].dn).lower(), ("CN=g2,%s" % self.ou_groups).lower())
529
530 res1 = self.ldb.search(self.ou_groups,
531 scope=SCOPE_SUBTREE,
532 expression="member:1.2.840.113556.1.4.1941:=<SID=%s>" % sid)
533 self.assertEqual(len(res1), 3)
534 dn_list = [str(res.dn).lower() for res in res1]
535 self.assertTrue(("CN=g2,%s" % self.ou_groups).lower() in dn_list)
536 self.assertTrue(("CN=g3,%s" % self.ou_groups).lower() in dn_list)
537 self.assertTrue(("CN=g4,%s" % self.ou_groups).lower() in dn_list)
538
539 res1 = self.ldb.search(self.ou_groups,
540 scope=SCOPE_ONELEVEL,
541 expression="member:1.2.840.113556.1.4.1941:=<SID=%s>" % sid)
542 self.assertEqual(len(res1), 3)
543 dn_list = [str(res.dn).lower() for res in res1]
544 self.assertTrue(("CN=g2,%s" % self.ou_groups).lower() in dn_list)
545 self.assertTrue(("CN=g3,%s" % self.ou_groups).lower() in dn_list)
546 self.assertTrue(("CN=g4,%s" % self.ou_groups).lower() in dn_list)
547
548 res1 = self.ldb.search(self.ou_groups,
549 scope=SCOPE_SUBTREE,
550 expression="member:1.2.840.113556.1.4.1941:=<GUID=%s>" % guid)
551 self.assertEqual(len(res1), 3)
552 dn_list = [str(res.dn).lower() for res in res1]
553 self.assertTrue(("CN=g2,%s" % self.ou_groups).lower() in dn_list)
554 self.assertTrue(("CN=g3,%s" % self.ou_groups).lower() in dn_list)
555 self.assertTrue(("CN=g4,%s" % self.ou_groups).lower() in dn_list)
556
557 res1 = self.ldb.search(self.ou_groups,
558 scope=SCOPE_ONELEVEL,
559 expression="member:1.2.840.113556.1.4.1941:=<GUID=%s>" % guid)
560 self.assertEqual(len(res1), 3)
561 dn_list = [str(res.dn).lower() for res in res1]
562 self.assertTrue(("CN=g2,%s" % self.ou_groups).lower() in dn_list)
563 self.assertTrue(("CN=g3,%s" % self.ou_groups).lower() in dn_list)
564 self.assertTrue(("CN=g4,%s" % self.ou_groups).lower() in dn_list)
565
566 def test_extended_dn_u3(self):
567 res1 = self.ldb.search("cn=u3,%s" % self.ou_users,
568 scope=SCOPE_BASE,
569 expression="objectClass=*",
570 attrs=['objectSid', 'objectGUID'])
571 self.assertEqual(len(res1), 1)
572 self.assertEqual(str(res1[0].dn).lower(), ("cn=u3,%s" % self.ou_users).lower())
573
574 sid = self.ldb.schema_format_value("objectSid", res1[0]["objectSid"][0]).decode('utf8')
575 guid = self.ldb.schema_format_value("objectGUID", res1[0]['objectGUID'][0]).decode('utf8')
576
577 res1 = self.ldb.search(self.ou_groups,
578 scope=SCOPE_SUBTREE,
579 expression="member=<SID=%s>" % sid)
580 self.assertEqual(len(res1), 1)
581 self.assertEqual(str(res1[0].dn).lower(), ("CN=g3,%s" % self.ou_groups).lower())
582
583 res1 = self.ldb.search(self.ou_groups,
584 scope=SCOPE_SUBTREE,
585 expression="member=<GUID=%s>" % guid)
586 self.assertEqual(len(res1), 1)
587 self.assertEqual(str(res1[0].dn).lower(), ("CN=g3,%s" % self.ou_groups).lower())
588
589 res1 = self.ldb.search(self.ou_groups,
590 scope=SCOPE_SUBTREE,
591 expression="member:1.2.840.113556.1.4.1941:=<SID=%s>" % sid)
592 self.assertEqual(len(res1), 2)
593 dn_list = [str(res.dn).lower() for res in res1]
594 self.assertTrue(("CN=g3,%s" % self.ou_groups).lower() in dn_list)
595 self.assertTrue(("CN=g4,%s" % self.ou_groups).lower() in dn_list)
596
597 res1 = self.ldb.search(self.ou_groups,
598 scope=SCOPE_ONELEVEL,
599 expression="member:1.2.840.113556.1.4.1941:=<SID=%s>" % sid)
600 self.assertEqual(len(res1), 2)
601 dn_list = [str(res.dn).lower() for res in res1]
602 self.assertTrue(("CN=g3,%s" % self.ou_groups).lower() in dn_list)
603 self.assertTrue(("CN=g4,%s" % self.ou_groups).lower() in dn_list)
604
605 res1 = self.ldb.search(self.ou_groups,
606 scope=SCOPE_SUBTREE,
607 expression="member:1.2.840.113556.1.4.1941:=<GUID=%s>" % guid)
608 self.assertEqual(len(res1), 2)
609 dn_list = [str(res.dn).lower() for res in res1]
610 self.assertTrue(("CN=g3,%s" % self.ou_groups).lower() in dn_list)
611 self.assertTrue(("CN=g4,%s" % self.ou_groups).lower() in dn_list)
612
613 res1 = self.ldb.search(self.ou_groups,
614 scope=SCOPE_ONELEVEL,
615 expression="member:1.2.840.113556.1.4.1941:=<GUID=%s>" % guid)
616 self.assertEqual(len(res1), 2)
617 dn_list = [str(res.dn).lower() for res in res1]
618 self.assertTrue(("CN=g3,%s" % self.ou_groups).lower() in dn_list)
619 self.assertTrue(("CN=g4,%s" % self.ou_groups).lower() in dn_list)
620
621 def test_extended_dn_u4(self):
622 res1 = self.ldb.search("cn=u4,%s" % self.ou_users,
623 scope=SCOPE_BASE,
624 expression="objectClass=*",
625 attrs=['objectSid', 'objectGUID'])
626 self.assertEqual(len(res1), 1)
627 self.assertEqual(str(res1[0].dn).lower(), ("cn=u4,%s" % self.ou_users).lower())
628
629 sid = self.ldb.schema_format_value("objectSid", res1[0]["objectSid"][0]).decode('utf8')
630 guid = self.ldb.schema_format_value("objectGUID", res1[0]['objectGUID'][0]).decode('utf8')
631
632 res1 = self.ldb.search(self.ou_groups,
633 scope=SCOPE_SUBTREE,
634 expression="member=<SID=%s>" % sid)
635 self.assertEqual(len(res1), 1)
636 self.assertEqual(str(res1[0].dn).lower(), ("CN=g4,%s" % self.ou_groups).lower())
637
638 res1 = self.ldb.search(self.ou_groups,
639 scope=SCOPE_SUBTREE,
640 expression="member=<GUID=%s>" % guid)
641 self.assertEqual(len(res1), 1)
642 self.assertEqual(str(res1[0].dn).lower(), ("CN=g4,%s" % self.ou_groups).lower())
643
644 res1 = self.ldb.search(self.ou_groups,
645 scope=SCOPE_ONELEVEL,
646 expression="member=<GUID=%s>" % guid)
647 self.assertEqual(len(res1), 1)
648 self.assertEqual(str(res1[0].dn).lower(), ("CN=g4,%s" % self.ou_groups).lower())
649
650 res1 = self.ldb.search(self.ou_groups,
651 scope=SCOPE_SUBTREE,
652 expression="member:1.2.840.113556.1.4.1941:=<SID=%s>" % sid)
653 self.assertEqual(len(res1), 1)
654 self.assertEqual(str(res1[0].dn).lower(), ("CN=g4,%s" % self.ou_groups).lower())
655
656 res1 = self.ldb.search(self.ou_groups,
657 scope=SCOPE_ONELEVEL,
658 expression="member:1.2.840.113556.1.4.1941:=<SID=%s>" % sid)
659 self.assertEqual(len(res1), 1)
660 self.assertEqual(str(res1[0].dn).lower(), ("CN=g4,%s" % self.ou_groups).lower())
661
662 res1 = self.ldb.search(self.ou_groups,
663 scope=SCOPE_SUBTREE,
664 expression="member:1.2.840.113556.1.4.1941:=<GUID=%s>" % guid)
665 self.assertEqual(len(res1), 1)
666 self.assertEqual(str(res1[0].dn).lower(), ("CN=g4,%s" % self.ou_groups).lower())
667
668 res1 = self.ldb.search(self.ou_groups,
669 scope=SCOPE_ONELEVEL,
670 expression="member:1.2.840.113556.1.4.1941:=<GUID=%s>" % guid)
671 self.assertEqual(len(res1), 1)
672 self.assertEqual(str(res1[0].dn).lower(), ("CN=g4,%s" % self.ou_groups).lower())
673
674 def test_object_dn_binary(self):
675 res1 = self.ldb.search(self.ou_computers,
676 scope=SCOPE_SUBTREE,
677 expression="msDS-RevealedUsers=B:8:01010101:cn=c3,%s" % self.ou_computers)
678 self.assertEqual(len(res1), 1)
679 self.assertEqual(str(res1[0].dn).lower(), ("CN=c2,%s" % self.ou_computers).lower())
680
681 res1 = self.ldb.search(self.ou_computers,
682 scope=SCOPE_ONELEVEL,
683 expression="msDS-RevealedUsers=B:8:01010101:cn=c3,%s" % self.ou_computers)
684 self.assertEqual(len(res1), 1)
685 self.assertEqual(str(res1[0].dn).lower(), ("CN=c2,%s" % self.ou_computers).lower())
686
687 res1 = self.ldb.search(self.ou_computers,
688 scope=SCOPE_SUBTREE,
689 expression="msDS-RevealedUsers:1.2.840.113556.1.4.1941:=B:8:01010101:cn=c3,%s" % self.ou_computers)
690 self.assertEqual(len(res1), 2)
691 dn_list = [str(res.dn).lower() for res in res1]
692 self.assertTrue(("CN=c1,%s" % self.ou_computers).lower() in dn_list)
693 self.assertTrue(("CN=c2,%s" % self.ou_computers).lower() in dn_list)
694
695 res1 = self.ldb.search(self.ou_computers,
696 scope=SCOPE_ONELEVEL,
697 expression="msDS-RevealedUsers:1.2.840.113556.1.4.1941:=B:8:01010101:cn=c3,%s" % self.ou_computers)
698 self.assertEqual(len(res1), 2)
699 dn_list = [str(res.dn).lower() for res in res1]
700 self.assertTrue(("CN=c1,%s" % self.ou_computers).lower() in dn_list)
701 self.assertTrue(("CN=c2,%s" % self.ou_computers).lower() in dn_list)
702
703 def test_one_way_links(self):
704 res1 = self.ldb.search(self.ou,
705 scope=SCOPE_SUBTREE,
706 expression="addressBookRoots2=cn=c1,%s" % self.ou_computers)
707 self.assertEqual(len(res1), 1)
708 self.assertEqual(str(res1[0].dn).lower(), ("CN=e2,%s" % self.ou).lower())
709
710 res1 = self.ldb.search(self.ou,
711 scope=SCOPE_ONELEVEL,
712 expression="addressBookRoots2=cn=c1,%s" % self.ou_computers)
713 self.assertEqual(len(res1), 1)
714 self.assertEqual(str(res1[0].dn).lower(), ("CN=e2,%s" % self.ou).lower())
715
716 res1 = self.ldb.search(self.ou,
717 scope=SCOPE_SUBTREE,
718 expression="addressBookRoots2:1.2.840.113556.1.4.1941:=cn=c1,%s" % self.ou_computers)
719 self.assertEqual(len(res1), 2)
720 dn_list = [str(res.dn).lower() for res in res1]
721 self.assertTrue(("CN=e1,%s" % self.ou).lower() in dn_list)
722 self.assertTrue(("CN=e2,%s" % self.ou).lower() in dn_list)
723
724 res1 = self.ldb.search(self.ou,
725 scope=SCOPE_ONELEVEL,
726 expression="addressBookRoots2:1.2.840.113556.1.4.1941:=cn=c1,%s" % self.ou_computers)
727 self.assertEqual(len(res1), 2)
728 dn_list = [str(res.dn).lower() for res in res1]
729 self.assertTrue(("CN=e1,%s" % self.ou).lower() in dn_list)
730 self.assertTrue(("CN=e2,%s" % self.ou).lower() in dn_list)
731
732 def test_not_linked_attrs(self):
733 res1 = self.ldb.search(self.base_dn,
734 scope=SCOPE_BASE,
735 expression="wellKnownObjects=B:32:aa312825768811d1aded00c04fd8d5cd:CN=computers,%s" % self.base_dn)
736 self.assertEqual(len(res1), 1)
737 self.assertEqual(str(res1[0].dn).lower(), self.base_dn.lower())
738
739 def test_invalid_basedn(self):
740 res1 = self.ldb.search(self.base_dn,
741 scope=SCOPE_SUBTREE,
742 expression="memberOf:1.2.840.113556.1.4.1941:=cn=c1,ou=computers,ou=matchrulestest,%sXX" % self.base_dn)
743 self.assertEqual(len(res1), 0)
744
745 res1 = self.ldb.search(self.base_dn,
746 scope=SCOPE_SUBTREE,
747 expression="memberOf:1.2.840.113556.1.4.1941:=cn=XX,ou=computers,ou=matchrulestest,%s" % self.base_dn)
748 self.assertEqual(len(res1), 0)
749
750 def test_subtree(self):
751 res1 = self.ldb.search(self.ou,
752 scope=SCOPE_SUBTREE,
753 expression="otherWellKnownObjects=B:32:00000000000000000000000000000004:OU=o4,OU=o3,OU=o2,OU=o1,%s" % self.ou)
754 self.assertEqual(len(res1), 1)
755 self.assertEqual(str(res1[0].dn).lower(), ("OU=o3,OU=o2,OU=o1,%s" % self.ou).lower())
756
757 res1 = self.ldb.search(self.ou,
758 scope=SCOPE_ONELEVEL,
759 expression="otherWellKnownObjects=B:32:00000000000000000000000000000004:OU=o4,OU=o3,OU=o2,OU=o1,%s" % self.ou)
760 self.assertEqual(len(res1), 0)
761
762 res1 = self.ldb.search(self.ou,
763 scope=SCOPE_SUBTREE,
764 expression="otherWellKnownObjects:1.2.840.113556.1.4.1941:=B:32:00000000000000000000000000000004:OU=o4,OU=o3,OU=o2,OU=o1,%s" % self.ou)
765 self.assertEqual(len(res1), 0)
766
767 res1 = self.ldb.search(self.ou,
768 scope=SCOPE_ONELEVEL,
769 expression="otherWellKnownObjects:1.2.840.113556.1.4.1941:=B:32:00000000000000000000000000000004:OU=o4,OU=o3,OU=o2,OU=o1,%s" % self.ou)
770 self.assertEqual(len(res1), 0)
771
772 def test_unknown_oid(self):
773 res1 = self.ldb.search("cn=g4,%s" % self.ou_groups,
774 scope=SCOPE_BASE,
775 expression="member:2.4.681.226012.2.8.3882:=cn=u1,%s" % self.ou_users)
776 self.assertEqual(len(res1), 0)
777
778 res1 = self.ldb.search("cn=g4,%s" % self.ou_groups,
779 scope=SCOPE_BASE,
780 expression="member:8.16.8720.1008448.8.32.15528:=cn=u1,%s" % self.ou_users)
781 self.assertEqual(len(res1), 0)
782
783 res1 = self.ldb.search("cn=g4,%s" % self.ou_groups,
784 scope=SCOPE_BASE,
785 expression="member:1.2.3.4:=cn=u1,%s" % self.ou_users)
786 self.assertEqual(len(res1), 0)
787
788 def test_nul_text(self):
789 self.assertRaises((ValueError,TypeError),
790 lambda: self.ldb.search("cn=g4,%s" % self.ou_groups,
791 scope=SCOPE_BASE,
792 expression="\00member:1.2.840.113556.1.4.1941:=cn=u1,%s" % self.ou_users))
793 self.assertRaises((ValueError,TypeError),
794 lambda: self.ldb.search("cn=g4,%s" % self.ou_groups,
795 scope=SCOPE_BASE,
796 expression="member:1.2.840\00.113556.1.4.1941:=cn=u1,%s" % self.ou_users))
797 self.assertRaises((ValueError,TypeError),
798 lambda: self.ldb.search("cn=g4,%s" % self.ou_groups,
799 scope=SCOPE_BASE,
800 expression="member:1.2.840.113556.1.4.1941:=cn=u1\00,%s" % self.ou_users))
801 self.assertRaises(LdbError,
802 lambda: self.ldb.search("cn=\00g4,%s" % self.ou_groups,
803 scope=SCOPE_BASE,
804 expression="member:1.2.840.113556.1.4.1941:=cn=u1,%s" % self.ou_users))
805 self.assertRaises(LdbError,
806 lambda: self.ldb.search("cn=g4,%s" % self.ou_groups,
807 scope=SCOPE_BASE,
808 expression="member:1.2.840.113556.1.4.1941:"))
809 res1 = self.ldb.search("cn=g4,%s" % self.ou_groups,
810 scope=SCOPE_BASE,
811 expression="member:1.2.840.113556.1.4.1941:=")
812 self.assertEqual(len(res1), 0)
813 res1 = self.ldb.search("cn=g4,%s" % self.ou_groups,
814 scope=SCOPE_BASE,
815 expression="member=")
816 self.assertEqual(len(res1), 0)
817 res1 = self.ldb.search("cn=g4,%s" % self.ou_groups,
818 scope=SCOPE_BASE,
819 expression="member:1.2.840.113556.1.4.1941:=nonexistent")
820 self.assertEqual(len(res1), 0)
821 res1 = self.ldb.search("cn=g4,%s" % self.ou_groups,
822 scope=SCOPE_BASE,
823 expression="member=nonexistent")
824 self.assertEqual(len(res1), 0)
825 self.assertRaises(LdbError,
826 lambda: self.ldb.search("cn=\00g4,%s" % self.ou_groups,
827 scope=SCOPE_BASE,
828 expression="member:1.2.840.113556.1.4.1941:cn=u1,%s" % self.ou_users))
829 self.assertRaises(LdbError,
830 lambda: self.ldb.search("cn=\00g4,%s" % self.ou_groups,
831 scope=SCOPE_BASE,
832 expression="member:1.2.840.113556.1.4.1941:=cn=u1"))
833 self.assertRaises(LdbError,
834 lambda: self.ldb.search("cn=\00g4,%s" % self.ou_groups,
835 scope=SCOPE_BASE,
836 expression="member:1.2.840.113556.1.4.1941:=cn="))
837 self.assertRaises(LdbError,
838 lambda: self.ldb.search("cn=\00g4,%s" % self.ou_groups,
839 scope=SCOPE_BASE,
840 expression="member::=cn=u1,%s" % self.ou_users))
841
842 def test_misc_matches(self):
843 res1 = self.ldb.search(self.ou_groups,
844 scope=SCOPE_BASE,
845 expression="member=cn=g1,%s" % self.ou_groups)
846 self.assertEqual(len(res1), 0)
847
848 res1 = self.ldb.search("cn=g1,%s" % self.ou_groups,
849 scope=SCOPE_BASE,
850 expression="member=cn=g1,%s" % self.ou_groups)
851 self.assertEqual(len(res1), 0)
852
853 res1 = self.ldb.search(self.ou_groups,
854 scope=SCOPE_SUBTREE,
855 expression="member=cn=g1,%s" % self.ou_groups)
856 self.assertEqual(len(res1), 1)
857 self.assertEqual(str(res1[0].dn), "CN=g2,%s" % self.ou_groups)
858
859 res1 = self.ldb.search(self.ou_groups,
860 scope=SCOPE_ONELEVEL,
861 expression="member=cn=g1,%s" % self.ou_groups)
862 self.assertEqual(len(res1), 1)
863 self.assertEqual(str(res1[0].dn), "CN=g2,%s" % self.ou_groups)
864
865 res1 = self.ldb.search(self.ou_groups,
866 scope=SCOPE_BASE,
867 expression="member:1.2.840.113556.1.4.1941:=cn=g1,%s" % self.ou_groups)
868 self.assertEqual(len(res1), 0)
869
870 res1 = self.ldb.search("cn=g1,%s" % self.ou_groups,
871 scope=SCOPE_BASE,
872 expression="member:1.2.840.113556.1.4.1941:=cn=g1,%s" % self.ou_groups)
873 self.assertEqual(len(res1), 0)
874
875 res1 = self.ldb.search(self.ou_groups,
876 scope=SCOPE_SUBTREE,
877 expression="member:1.2.840.113556.1.4.1941:=cn=g1,%s" % self.ou_groups)
878 self.assertEqual(len(res1), 3)
879 dn_list = [str(res.dn) for res in res1]
880 self.assertTrue("CN=g2,%s" % self.ou_groups in dn_list)
881 self.assertTrue("CN=g3,%s" % self.ou_groups in dn_list)
882 self.assertTrue("CN=g4,%s" % self.ou_groups in dn_list)
883
884 res1 = self.ldb.search(self.ou_groups,
885 scope=SCOPE_ONELEVEL,
886 expression="member:1.2.840.113556.1.4.1941:=cn=g1,%s" % self.ou_groups)
887 self.assertEqual(len(res1), 3)
888 dn_list = [str(res.dn) for res in res1]
889 self.assertTrue("CN=g2,%s" % self.ou_groups in dn_list)
890 self.assertTrue("CN=g3,%s" % self.ou_groups in dn_list)
891 self.assertTrue("CN=g4,%s" % self.ou_groups in dn_list)
892
893 res1 = self.ldb.search(self.ou_groups,
894 scope=SCOPE_SUBTREE,
895 expression="member:1.2.840.113556.1.4.1941:=cn=g4,%s" % self.ou_groups)
896 self.assertEqual(len(res1), 0)
897
898 res1 = self.ldb.search(self.ou_groups,
899 scope=SCOPE_ONELEVEL,
900 expression="member:1.2.840.113556.1.4.1941:=cn=g4,%s" % self.ou_groups)
901 self.assertEqual(len(res1), 0)
902
903 res1 = self.ldb.search(self.ou_groups,
904 scope=SCOPE_BASE,
905 expression="memberOf=cn=g4,%s" % self.ou_groups)
906 self.assertEqual(len(res1), 0)
907
908 res1 = self.ldb.search("cn=g4,%s" % self.ou_groups,
909 scope=SCOPE_BASE,
910 expression="memberOf=cn=g4,%s" % self.ou_groups)
911 self.assertEqual(len(res1), 0)
912
913 res1 = self.ldb.search(self.ou_groups,
914 scope=SCOPE_SUBTREE,
915 expression="memberOf=cn=g4,%s" % self.ou_groups)
916 self.assertEqual(len(res1), 1)
917 self.assertEqual(str(res1[0].dn), ("CN=g3,%s" % self.ou_groups))
918
919 res1 = self.ldb.search(self.ou_groups,
920 scope=SCOPE_ONELEVEL,
921 expression="memberOf=cn=g4,%s" % self.ou_groups)
922 self.assertEqual(len(res1), 1)
923 self.assertEqual(str(res1[0].dn), ("CN=g3,%s" % self.ou_groups))
924
925 res1 = self.ldb.search(self.ou_groups,
926 scope=SCOPE_BASE,
927 expression="memberOf:1.2.840.113556.1.4.1941:=cn=g4,%s" % self.ou_groups)
928 self.assertEqual(len(res1), 0)
929
930 res1 = self.ldb.search("cn=g4,%s" % self.ou_groups,
931 scope=SCOPE_BASE,
932 expression="memberOf:1.2.840.113556.1.4.1941:=cn=g4,%s" % self.ou_groups)
933 self.assertEqual(len(res1), 0)
934
935 res1 = self.ldb.search(self.ou_groups,
936 scope=SCOPE_SUBTREE,
937 expression="memberOf:1.2.840.113556.1.4.1941:=cn=g4,%s" % self.ou_groups)
938 self.assertEqual(len(res1), 3)
939 dn_list = [str(res.dn) for res in res1]
940 self.assertTrue("CN=g1,%s" % self.ou_groups in dn_list)
941 self.assertTrue("CN=g2,%s" % self.ou_groups in dn_list)
942 self.assertTrue("CN=g3,%s" % self.ou_groups in dn_list)
943
944 res1 = self.ldb.search(self.ou_groups,
945 scope=SCOPE_ONELEVEL,
946 expression="memberOf:1.2.840.113556.1.4.1941:=cn=g4,%s" % self.ou_groups)
947 self.assertEqual(len(res1), 3)
948 dn_list = [str(res.dn) for res in res1]
949 self.assertTrue("CN=g1,%s" % self.ou_groups in dn_list)
950 self.assertTrue("CN=g2,%s" % self.ou_groups in dn_list)
951 self.assertTrue("CN=g3,%s" % self.ou_groups in dn_list)
952
953 res1 = self.ldb.search(self.ou_groups,
954 scope=SCOPE_SUBTREE,
955 expression="memberOf:1.2.840.113556.1.4.1941:=cn=g1,%s" % self.ou_groups)
956 self.assertEqual(len(res1), 0)
957
958 res1 = self.ldb.search(self.ou_groups,
959 scope=SCOPE_SUBTREE,
960 expression="memberOf:1.2.840.113556.1.4.1941:=cn=g1,%s" % self.ou_groups)
961 self.assertEqual(len(res1), 0)
962
963
964 class MatchRuleConditionTests(samba.tests.TestCase):
965 def setUp(self):
966 super(MatchRuleConditionTests, self).setUp()
967 self.lp = sambaopts.get_loadparm()
968 self.creds = credopts.get_credentials(self.lp)
969
970 self.ldb = SamDB(host, credentials=self.creds,
971 session_info=system_session(self.lp),
972 lp=self.lp)
973 self.base_dn = self.ldb.domain_dn()
974 self.ou = "OU=matchruleconditiontests,%s" % self.base_dn
975 self.ou_users = "OU=users,%s" % self.ou
976 self.ou_groups = "OU=groups,%s" % self.ou
977 self.ou_computers = "OU=computers,%s" % self.ou
978
979 # Add a organizational unit to create objects
980 self.ldb.add({
981 "dn": self.ou,
982 "objectclass": "organizationalUnit"})
983
984 # Create users, groups, and computers
985 self.ldb.add({
986 "dn": self.ou_users,
987 "objectclass": "organizationalUnit"})
988 self.ldb.add({
989 "dn": self.ou_groups,
990 "objectclass": "organizationalUnit"})
991 self.ldb.add({
992 "dn": self.ou_computers,
993 "objectclass": "organizationalUnit"})
994
995 self.ldb.add({
996 "dn": "cn=g1,%s" % self.ou_groups,
997 "objectclass": "group"})
998 self.ldb.add({
999 "dn": "cn=g2,%s" % self.ou_groups,
1000 "objectclass": "group"})
1001 self.ldb.add({
1002 "dn": "cn=g3,%s" % self.ou_groups,
1003 "objectclass": "group"})
1004 self.ldb.add({
1005 "dn": "cn=g4,%s" % self.ou_groups,
1006 "objectclass": "group"})
1007
1008 self.ldb.add({
1009 "dn": "cn=u1,%s" % self.ou_users,
1010 "objectclass": "group"})
1011 self.ldb.add({
1012 "dn": "cn=u2,%s" % self.ou_users,
1013 "objectclass": "group"})
1014 self.ldb.add({
1015 "dn": "cn=u3,%s" % self.ou_users,
1016 "objectclass": "group"})
1017 self.ldb.add({
1018 "dn": "cn=u4,%s" % self.ou_users,
1019 "objectclass": "group"})
1020
1021 self.ldb.add({
1022 "dn": "cn=c1,%s" % self.ou_computers,
1023 "objectclass": "user"})
1024
1025 self.ldb.add({
1026 "dn": "cn=c2,%s" % self.ou_computers,
1027 "objectclass": "user"})
1028
1029 self.ldb.add({
1030 "dn": "cn=c3,%s" % self.ou_computers,
1031 "objectclass": "user"})
1032
1033 self.ldb.add({
1034 "dn": "cn=c4,%s" % self.ou_computers,
1035 "objectclass": "user"})
1036
1037 # Assign groups according to the following structure:
1038 # g1-->g2---->g3 --g4
1039 # \ | / | / / |
1040 # u1- >u2-- | u3<- | u4
1041 # \ \ \ \ |
1042 # c1* >c2 ->c3 c4
1043 # *c1 is a member of u1, u2, u3, and u4
1044
1045 # u2 is a member of g1 and g2
1046 m = Message()
1047 m.dn = Dn(self.ldb, "CN=g1,%s" % self.ou_groups)
1048 m["member"] = MessageElement("CN=u2,%s" % self.ou_users,
1049 FLAG_MOD_ADD, "member")
1050 self.ldb.modify(m)
1051
1052 m = Message()
1053 m.dn = Dn(self.ldb, "CN=g2,%s" % self.ou_groups)
1054 m["member"] = MessageElement("CN=u2,%s" % self.ou_users,
1055 FLAG_MOD_ADD, "member")
1056 self.ldb.modify(m)
1057
1058 # g2 is a member of g1
1059 m = Message()
1060 m.dn = Dn(self.ldb, "CN=g1,%s" % self.ou_groups)
1061 m["member"] = MessageElement("CN=g2,%s" % self.ou_groups,
1062 FLAG_MOD_ADD, "member")
1063 self.ldb.modify(m)
1064
1065 # g3 is a member of g2
1066 m = Message()
1067 m.dn = Dn(self.ldb, "CN=g2,%s" % self.ou_groups)
1068 m["member"] = MessageElement("CN=g3,%s" % self.ou_groups,
1069 FLAG_MOD_ADD, "member")
1070 self.ldb.modify(m)
1071
1072 # u3 is a member of g3 and g4
1073 m = Message()
1074 m.dn = Dn(self.ldb, "CN=g3,%s" % self.ou_groups)
1075 m["member"] = MessageElement("CN=u3,%s" % self.ou_users,
1076 FLAG_MOD_ADD, "member")
1077 self.ldb.modify(m)
1078
1079 m = Message()
1080 m.dn = Dn(self.ldb, "CN=g4,%s" % self.ou_groups)
1081 m["member"] = MessageElement("CN=u3,%s" % self.ou_users,
1082 FLAG_MOD_ADD, "member")
1083 self.ldb.modify(m)
1084
1085 # u4 is a member of g4
1086 m = Message()
1087 m.dn = Dn(self.ldb, "CN=g4,%s" % self.ou_groups)
1088 m["member"] = MessageElement("CN=u4,%s" % self.ou_users,
1089 FLAG_MOD_ADD, "member")
1090 self.ldb.modify(m)
1091
1092 # c1 is a member of u1, u2, u3, and u4
1093 m = Message()
1094 m.dn = Dn(self.ldb, "CN=u1,%s" % self.ou_users)
1095 m["member"] = MessageElement("CN=c1,%s" % self.ou_computers,
1096 FLAG_MOD_ADD, "member")
1097 self.ldb.modify(m)
1098
1099 m = Message()
1100 m.dn = Dn(self.ldb, "CN=u2,%s" % self.ou_users)
1101 m["member"] = MessageElement("CN=c1,%s" % self.ou_computers,
1102 FLAG_MOD_ADD, "member")
1103 self.ldb.modify(m)
1104
1105 m = Message()
1106 m.dn = Dn(self.ldb, "CN=u3,%s" % self.ou_users)
1107 m["member"] = MessageElement("CN=c1,%s" % self.ou_computers,
1108 FLAG_MOD_ADD, "member")
1109 self.ldb.modify(m)
1110
1111 m = Message()
1112 m.dn = Dn(self.ldb, "CN=u4,%s" % self.ou_users)
1113 m["member"] = MessageElement("CN=c1,%s" % self.ou_computers,
1114 FLAG_MOD_ADD, "member")
1115 self.ldb.modify(m)
1116
1117 # c2 is a member of u1
1118 m = Message()
1119 m.dn = Dn(self.ldb, "CN=u1,%s" % self.ou_users)
1120 m["member"] = MessageElement("CN=c2,%s" % self.ou_computers,
1121 FLAG_MOD_ADD, "member")
1122 self.ldb.modify(m)
1123
1124 # c3 is a member of u2 and g3
1125 m = Message()
1126 m.dn = Dn(self.ldb, "CN=u2,%s" % self.ou_users)
1127 m["member"] = MessageElement("CN=c3,%s" % self.ou_computers,
1128 FLAG_MOD_ADD, "member")
1129 self.ldb.modify(m)
1130
1131 m = Message()
1132 m.dn = Dn(self.ldb, "CN=g3,%s" % self.ou_groups)
1133 m["member"] = MessageElement("CN=c3,%s" % self.ou_computers,
1134 FLAG_MOD_ADD, "member")
1135 self.ldb.modify(m)
1136
1137 # c4 is a member of u4 and g4
1138 m = Message()
1139 m.dn = Dn(self.ldb, "CN=u4,%s" % self.ou_users)
1140 m["member"] = MessageElement("CN=c4,%s" % self.ou_computers,
1141 FLAG_MOD_ADD, "member")
1142 self.ldb.modify(m)
1143
1144 m = Message()
1145 m.dn = Dn(self.ldb, "CN=g4,%s" % self.ou_groups)
1146 m["member"] = MessageElement("CN=c4,%s" % self.ou_computers,
1147 FLAG_MOD_ADD, "member")
1148 self.ldb.modify(m)
1149
1150 def tearDown(self):
1151 super(MatchRuleConditionTests, self).tearDown()
1152 self.ldb.delete(self.ou, controls=['tree_delete:0'])
1153
1154 def test_g1_members(self):
1155 res1 = self.ldb.search(self.ou,
1156 scope=SCOPE_SUBTREE,
1157 expression="memberOf=cn=g1,%s" % self.ou_groups)
1158 self.assertEqual(len(res1), 2)
1159 dn_list = [str(res.dn) for res in res1]
1160 self.assertTrue("CN=g2,%s" % self.ou_groups in dn_list)
1161 self.assertTrue("CN=u2,%s" % self.ou_users in dn_list)
1162
1163 res1 = self.ldb.search(self.ou,
1164 scope=SCOPE_SUBTREE,
1165 expression="memberOf:1.2.840.113556.1.4.1941:=cn=g1,%s" % self.ou_groups)
1166 self.assertEqual(len(res1), 6)
1167 dn_list = [str(res.dn) for res in res1]
1168 self.assertTrue("CN=u2,%s" % self.ou_users in dn_list)
1169 self.assertTrue("CN=u3,%s" % self.ou_users in dn_list)
1170 self.assertTrue("CN=g2,%s" % self.ou_groups in dn_list)
1171 self.assertTrue("CN=g3,%s" % self.ou_groups in dn_list)
1172 self.assertTrue("CN=c1,%s" % self.ou_computers in dn_list)
1173 self.assertTrue("CN=c3,%s" % self.ou_computers in dn_list)
1174
1175 res1 = self.ldb.search(self.ou,
1176 scope=SCOPE_SUBTREE,
1177 expression="member=cn=g1,%s" % self.ou_groups)
1178 self.assertEqual(len(res1), 0)
1179
1180 res1 = self.ldb.search(self.ou,
1181 scope=SCOPE_SUBTREE,
1182 expression="member:1.2.840.113556.1.4.1941:=cn=g1,%s" % self.ou_groups)
1183 self.assertEqual(len(res1), 0)
1184
1185 def test_g2_members(self):
1186 res1 = self.ldb.search(self.ou,
1187 scope=SCOPE_SUBTREE,
1188 expression="memberOf=cn=g2,%s" % self.ou_groups)
1189 self.assertEqual(len(res1), 2)
1190 dn_list = [str(res.dn) for res in res1]
1191 self.assertTrue("CN=g3,%s" % self.ou_groups in dn_list)
1192 self.assertTrue("CN=u2,%s" % self.ou_users in dn_list)
1193
1194 res1 = self.ldb.search(self.ou,
1195 scope=SCOPE_SUBTREE,
1196 expression="memberOf:1.2.840.113556.1.4.1941:=cn=g2,%s" % self.ou_groups)
1197 self.assertEqual(len(res1), 5)
1198 dn_list = [str(res.dn) for res in res1]
1199 self.assertTrue("CN=u2,%s" % self.ou_users in dn_list)
1200 self.assertTrue("CN=u3,%s" % self.ou_users in dn_list)
1201 self.assertTrue("CN=g3,%s" % self.ou_groups in dn_list)
1202 self.assertTrue("CN=c1,%s" % self.ou_computers in dn_list)
1203 self.assertTrue("CN=c3,%s" % self.ou_computers in dn_list)
1204
1205 res1 = self.ldb.search(self.ou,
1206 scope=SCOPE_SUBTREE,
1207 expression="member=cn=g2,%s" % self.ou_groups)
1208 self.assertEqual(len(res1), 1)
1209 self.assertEqual(str(res1[0].dn), "CN=g1,%s" % self.ou_groups)
1210
1211 res1 = self.ldb.search(self.ou,
1212 scope=SCOPE_SUBTREE,
1213 expression="member:1.2.840.113556.1.4.1941:=cn=g2,%s" % self.ou_groups)
1214 self.assertEqual(len(res1), 1)
1215 self.assertEqual(str(res1[0].dn), "CN=g1,%s" % self.ou_groups)
1216
1217 def test_g3_members(self):
1218 res1 = self.ldb.search(self.ou,
1219 scope=SCOPE_SUBTREE,
1220 expression="memberOf=cn=g3,%s" % self.ou_groups)
1221 self.assertEqual(len(res1), 2)
1222 dn_list = [str(res.dn) for res in res1]
1223 self.assertTrue("CN=u3,%s" % self.ou_users in dn_list)
1224 self.assertTrue("CN=c3,%s" % self.ou_computers in dn_list)
1225
1226 res1 = self.ldb.search(self.ou,
1227 scope=SCOPE_SUBTREE,
1228 expression="memberOf:1.2.840.113556.1.4.1941:=cn=g3,%s" % self.ou_groups)
1229 self.assertEqual(len(res1), 3)
1230 dn_list = [str(res.dn) for res in res1]
1231 self.assertTrue("CN=u3,%s" % self.ou_users in dn_list)
1232 self.assertTrue("CN=c1,%s" % self.ou_computers in dn_list)
1233 self.assertTrue("CN=c3,%s" % self.ou_computers in dn_list)
1234
1235 res1 = self.ldb.search(self.ou,
1236 scope=SCOPE_SUBTREE,
1237 expression="member=cn=g3,%s" % self.ou_groups)
1238 self.assertEqual(len(res1), 1)
1239 self.assertEqual(str(res1[0].dn), "CN=g2,%s" % self.ou_groups)
1240
1241 res1 = self.ldb.search(self.ou,
1242 scope=SCOPE_SUBTREE,
1243 expression="member:1.2.840.113556.1.4.1941:=cn=g3,%s" % self.ou_groups)
1244 self.assertEqual(len(res1), 2)
1245 dn_list = [str(res.dn) for res in res1]
1246 self.assertTrue("CN=g1,%s" % self.ou_groups in dn_list)
1247 self.assertTrue("CN=g2,%s" % self.ou_groups in dn_list)
1248
1249 def test_g4_members(self):
1250 res1 = self.ldb.search(self.ou,
1251 scope=SCOPE_SUBTREE,
1252 expression="memberOf=cn=g4,%s" % self.ou_groups)
1253 self.assertEqual(len(res1), 3)
1254 dn_list = [str(res.dn) for res in res1]
1255 self.assertTrue("CN=u3,%s" % self.ou_users in dn_list)
1256 self.assertTrue("CN=u4,%s" % self.ou_users in dn_list)
1257 self.assertTrue("CN=c4,%s" % self.ou_computers in dn_list)
1258
1259 res1 = self.ldb.search(self.ou,
1260 scope=SCOPE_SUBTREE,
1261 expression="memberOf:1.2.840.113556.1.4.1941:=cn=g4,%s" % self.ou_groups)
1262 self.assertEqual(len(res1), 4)
1263 dn_list = [str(res.dn) for res in res1]
1264 self.assertTrue("CN=u3,%s" % self.ou_users in dn_list)
1265 self.assertTrue("CN=u4,%s" % self.ou_users in dn_list)
1266 self.assertTrue("CN=c1,%s" % self.ou_computers in dn_list)
1267 self.assertTrue("CN=c4,%s" % self.ou_computers in dn_list)
1268
1269 res1 = self.ldb.search(self.ou,
1270 scope=SCOPE_SUBTREE,
1271 expression="member=cn=g4,%s" % self.ou_groups)
1272 self.assertEqual(len(res1), 0)
1273
1274 res1 = self.ldb.search(self.ou,
1275 scope=SCOPE_SUBTREE,
1276 expression="member:1.2.840.113556.1.4.1941:=cn=g4,%s" % self.ou_groups)
1277 self.assertEqual(len(res1), 0)
1278
1279 def test_u1_members(self):
1280 res1 = self.ldb.search(self.ou,
1281 scope=SCOPE_SUBTREE,
1282 expression="memberOf=cn=u1,%s" % self.ou_users)
1283 self.assertEqual(len(res1), 2)
1284 dn_list = [str(res.dn) for res in res1]
1285 self.assertTrue("CN=c1,%s" % self.ou_computers in dn_list)
1286 self.assertTrue("CN=c2,%s" % self.ou_computers in dn_list)
1287
1288 res1 = self.ldb.search(self.ou,
1289 scope=SCOPE_SUBTREE,
1290 expression="memberOf:1.2.840.113556.1.4.1941:=cn=u1,%s" % self.ou_users)
1291 self.assertEqual(len(res1), 2)
1292 dn_list = [str(res.dn) for res in res1]
1293 self.assertTrue("CN=c1,%s" % self.ou_computers in dn_list)
1294 self.assertTrue("CN=c2,%s" % self.ou_computers in dn_list)
1295
1296 res1 = self.ldb.search(self.ou,
1297 scope=SCOPE_SUBTREE,
1298 expression="member=cn=u1,%s" % self.ou_users)
1299 self.assertEqual(len(res1), 0)
1300
1301 res1 = self.ldb.search(self.ou,
1302 scope=SCOPE_SUBTREE,
1303 expression="member:1.2.840.113556.1.4.1941:=cn=u1,%s" % self.ou_users)
1304 self.assertEqual(len(res1), 0)
1305
1306 def test_u2_members(self):
1307 res1 = self.ldb.search(self.ou,
1308 scope=SCOPE_SUBTREE,
1309 expression="memberOf=cn=u2,%s" % self.ou_users)
1310 self.assertEqual(len(res1), 2)
1311 dn_list = [str(res.dn) for res in res1]
1312 self.assertTrue("CN=c1,%s" % self.ou_computers in dn_list)
1313 self.assertTrue("CN=c3,%s" % self.ou_computers in dn_list)
1314
1315 res1 = self.ldb.search(self.ou,
1316 scope=SCOPE_SUBTREE,
1317 expression="memberOf:1.2.840.113556.1.4.1941:=cn=u2,%s" % self.ou_users)
1318 self.assertEqual(len(res1), 2)
1319 dn_list = [str(res.dn) for res in res1]
1320 self.assertTrue("CN=c1,%s" % self.ou_computers in dn_list)
1321 self.assertTrue("CN=c3,%s" % self.ou_computers in dn_list)
1322
1323 res1 = self.ldb.search(self.ou,
1324 scope=SCOPE_SUBTREE,
1325 expression="member=cn=u2,%s" % self.ou_users)
1326 self.assertEqual(len(res1), 2)
1327 dn_list = [str(res.dn) for res in res1]
1328 self.assertTrue("CN=g1,%s" % self.ou_groups in dn_list)
1329 self.assertTrue("CN=g2,%s" % self.ou_groups in dn_list)
1330
1331 res1 = self.ldb.search(self.ou,
1332 scope=SCOPE_SUBTREE,
1333 expression="member:1.2.840.113556.1.4.1941:=cn=u2,%s" % self.ou_users)
1334 self.assertEqual(len(res1), 2)
1335 dn_list = [str(res.dn) for res in res1]
1336 self.assertTrue("CN=g1,%s" % self.ou_groups in dn_list)
1337 self.assertTrue("CN=g2,%s" % self.ou_groups in dn_list)
1338
1339 def test_u3_members(self):
1340 res1 = self.ldb.search(self.ou,
1341 scope=SCOPE_SUBTREE,
1342 expression="member=cn=u3,%s" % self.ou_users)
1343 self.assertEqual(len(res1), 2)
1344 dn_list = [str(res.dn) for res in res1]
1345 self.assertTrue("CN=g3,%s" % self.ou_groups in dn_list)
1346 self.assertTrue("CN=g4,%s" % self.ou_groups in dn_list)
1347
1348 res1 = self.ldb.search(self.ou,
1349 scope=SCOPE_SUBTREE,
1350 expression="member:1.2.840.113556.1.4.1941:=cn=u3,%s" % self.ou_users)
1351 self.assertEqual(len(res1), 4)
1352 dn_list = [str(res.dn) for res in res1]
1353 self.assertTrue("CN=g1,%s" % self.ou_groups in dn_list)
1354 self.assertTrue("CN=g2,%s" % self.ou_groups in dn_list)
1355 self.assertTrue("CN=g3,%s" % self.ou_groups in dn_list)
1356 self.assertTrue("CN=g4,%s" % self.ou_groups in dn_list)
1357
1358 res1 = self.ldb.search(self.ou,
1359 scope=SCOPE_SUBTREE,
1360 expression="memberOf=cn=u3,%s" % self.ou_users)
1361 self.assertEqual(len(res1), 1)
1362 self.assertEqual(str(res1[0].dn), "CN=c1,%s" % self.ou_computers)
1363
1364 res1 = self.ldb.search(self.ou,
1365 scope=SCOPE_SUBTREE,
1366 expression="memberOf:1.2.840.113556.1.4.1941:=cn=u3,%s" % self.ou_users)
1367 self.assertEqual(len(res1), 1)
1368 self.assertEqual(str(res1[0].dn), "CN=c1,%s" % self.ou_computers)
1369
1370 def test_u4_members(self):
1371 res1 = self.ldb.search(self.ou,
1372 scope=SCOPE_SUBTREE,
1373 expression="member=cn=u4,%s" % self.ou_users)
1374 self.assertEqual(len(res1), 1)
1375 self.assertEqual(str(res1[0].dn), "CN=g4,%s" % self.ou_groups)
1376
1377 res1 = self.ldb.search(self.ou,
1378 scope=SCOPE_SUBTREE,
1379 expression="member:1.2.840.113556.1.4.1941:=cn=u4,%s" % self.ou_users)
1380 self.assertEqual(len(res1), 1)
1381 self.assertEqual(str(res1[0].dn), "CN=g4,%s" % self.ou_groups)
1382
1383 res1 = self.ldb.search(self.ou,
1384 scope=SCOPE_SUBTREE,
1385 expression="memberOf=cn=u4,%s" % self.ou_users)
1386 self.assertEqual(len(res1), 2)
1387 dn_list = [str(res.dn) for res in res1]
1388 self.assertTrue("CN=c1,%s" % self.ou_computers in dn_list)
1389 self.assertTrue("CN=c4,%s" % self.ou_computers in dn_list)
1390
1391 res1 = self.ldb.search(self.ou,
1392 scope=SCOPE_SUBTREE,
1393 expression="memberOf:1.2.840.113556.1.4.1941:=cn=u4,%s" % self.ou_users)
1394 self.assertEqual(len(res1), 2)
1395 dn_list = [str(res.dn) for res in res1]
1396 self.assertTrue("CN=c1,%s" % self.ou_computers in dn_list)
1397 self.assertTrue("CN=c4,%s" % self.ou_computers in dn_list)
1398
1399 def test_c1_members(self):
1400 res1 = self.ldb.search(self.ou,
1401 scope=SCOPE_SUBTREE,
1402 expression="member=cn=c1,%s" % self.ou_computers)
1403 self.assertEqual(len(res1), 4)
1404 dn_list = [str(res.dn) for res in res1]
1405 self.assertTrue("CN=u1,%s" % self.ou_users in dn_list)
1406 self.assertTrue("CN=u2,%s" % self.ou_users in dn_list)
1407 self.assertTrue("CN=u3,%s" % self.ou_users in dn_list)
1408 self.assertTrue("CN=u4,%s" % self.ou_users in dn_list)
1409
1410 res1 = self.ldb.search(self.ou,
1411 scope=SCOPE_SUBTREE,
1412 expression="member:1.2.840.113556.1.4.1941:=cn=c1,%s" % self.ou_computers)
1413 self.assertEqual(len(res1), 8)
1414 dn_list = [str(res.dn) for res in res1]
1415 self.assertTrue("CN=u1,%s" % self.ou_users in dn_list)
1416 self.assertTrue("CN=u2,%s" % self.ou_users in dn_list)
1417 self.assertTrue("CN=u3,%s" % self.ou_users in dn_list)
1418 self.assertTrue("CN=u4,%s" % self.ou_users in dn_list)
1419 self.assertTrue("CN=g1,%s" % self.ou_groups in dn_list)
1420 self.assertTrue("CN=g2,%s" % self.ou_groups in dn_list)
1421 self.assertTrue("CN=g3,%s" % self.ou_groups in dn_list)
1422 self.assertTrue("CN=g4,%s" % self.ou_groups in dn_list)
1423
1424 res1 = self.ldb.search(self.ou,
1425 scope=SCOPE_SUBTREE,
1426 expression="memberOf=cn=c1,%s" % self.ou_computers)
1427 self.assertEqual(len(res1), 0)
1428
1429 res1 = self.ldb.search(self.ou,
1430 scope=SCOPE_SUBTREE,
1431 expression="memberOf:1.2.840.113556.1.4.1941:=cn=c1,%s" % self.ou_computers)
1432 self.assertEqual(len(res1), 0)
1433
1434 def test_c2_members(self):
1435 res1 = self.ldb.search(self.ou,
1436 scope=SCOPE_SUBTREE,
1437 expression="member=cn=c2,%s" % self.ou_computers)
1438 self.assertEqual(len(res1), 1)
1439 self.assertEqual(str(res1[0].dn), "CN=u1,%s" % self.ou_users)
1440
1441 res1 = self.ldb.search(self.ou,
1442 scope=SCOPE_SUBTREE,
1443 expression="member:1.2.840.113556.1.4.1941:=cn=c2,%s" % self.ou_computers)
1444 self.assertEqual(len(res1), 1)
1445 self.assertEqual(str(res1[0].dn), "CN=u1,%s" % self.ou_users)
1446
1447 res1 = self.ldb.search(self.ou,
1448 scope=SCOPE_SUBTREE,
1449 expression="memberOf=cn=c2,%s" % self.ou_computers)
1450 self.assertEqual(len(res1), 0)
1451
1452 res1 = self.ldb.search(self.ou,
1453 scope=SCOPE_SUBTREE,
1454 expression="memberOf:1.2.840.113556.1.4.1941:=cn=c2,%s" % self.ou_computers)
1455 self.assertEqual(len(res1), 0)
1456
1457 def test_c3_members(self):
1458 res1 = self.ldb.search(self.ou,
1459 scope=SCOPE_SUBTREE,
1460 expression="member=cn=c3,%s" % self.ou_computers)
1461 self.assertEqual(len(res1), 2)
1462 dn_list = [str(res.dn) for res in res1]
1463 self.assertTrue("CN=g3,%s" % self.ou_groups in dn_list)
1464 self.assertTrue("CN=u2,%s" % self.ou_users in dn_list)
1465
1466 res1 = self.ldb.search(self.ou,
1467 scope=SCOPE_SUBTREE,
1468 expression="member:1.2.840.113556.1.4.1941:=cn=c3,%s" % self.ou_computers)
1469 self.assertEqual(len(res1), 4)
1470 dn_list = [str(res.dn) for res in res1]
1471 self.assertTrue("CN=u2,%s" % self.ou_users in dn_list)
1472 self.assertTrue("CN=g1,%s" % self.ou_groups in dn_list)
1473 self.assertTrue("CN=g2,%s" % self.ou_groups in dn_list)
1474 self.assertTrue("CN=g3,%s" % self.ou_groups in dn_list)
1475
1476 res1 = self.ldb.search(self.ou,
1477 scope=SCOPE_SUBTREE,
1478 expression="memberOf=cn=c3,%s" % self.ou_computers)
1479 self.assertEqual(len(res1), 0)
1480
1481 res1 = self.ldb.search(self.ou,
1482 scope=SCOPE_SUBTREE,
1483 expression="memberOf:1.2.840.113556.1.4.1941:=cn=c3,%s" % self.ou_computers)
1484 self.assertEqual(len(res1), 0)
1485
1486 def test_c4_members(self):
1487 res1 = self.ldb.search(self.ou,
1488 scope=SCOPE_SUBTREE,
1489 expression="member=cn=c4,%s" % self.ou_computers)
1490 self.assertEqual(len(res1), 2)
1491 dn_list = [str(res.dn) for res in res1]
1492 self.assertTrue("CN=g4,%s" % self.ou_groups in dn_list)
1493 self.assertTrue("CN=u4,%s" % self.ou_users in dn_list)
1494
1495 res1 = self.ldb.search(self.ou,
1496 scope=SCOPE_SUBTREE,
1497 expression="member:1.2.840.113556.1.4.1941:=cn=c4,%s" % self.ou_computers)
1498 self.assertEqual(len(res1), 2)
1499 dn_list = [str(res.dn) for res in res1]
1500 self.assertTrue("CN=u4,%s" % self.ou_users in dn_list)
1501 self.assertTrue("CN=g4,%s" % self.ou_groups in dn_list)
1502
1503 res1 = self.ldb.search(self.ou,
1504 scope=SCOPE_SUBTREE,
1505 expression="memberOf=cn=c4,%s" % self.ou_computers)
1506 self.assertEqual(len(res1), 0)
1507
1508 res1 = self.ldb.search(self.ou,
1509 scope=SCOPE_SUBTREE,
1510 expression="memberOf:1.2.840.113556.1.4.1941:=cn=c4,%s" % self.ou_computers)
1511 self.assertEqual(len(res1), 0)
1512
1513 def test_or_member_queries(self):
1514 res1 = self.ldb.search(self.ou,
1515 scope=SCOPE_SUBTREE,
1516 expression=("(|(member:1.2.840.113556.1.4.1941:=cn=c1,%s)"
1517 "(member:1.2.840.113556.1.4.1941:=cn=c2,%s))") % (
1518 self.ou_computers, self.ou_computers))
1519 self.assertEqual(len(res1), 8)
1520 dn_list = [str(res.dn) for res in res1]
1521 self.assertTrue("CN=u1,%s" % self.ou_users in dn_list)
1522 self.assertTrue("CN=u2,%s" % self.ou_users in dn_list)
1523 self.assertTrue("CN=u3,%s" % self.ou_users in dn_list)
1524 self.assertTrue("CN=u4,%s" % self.ou_users in dn_list)
1525 self.assertTrue("CN=g1,%s" % self.ou_groups in dn_list)
1526 self.assertTrue("CN=g2,%s" % self.ou_groups in dn_list)
1527 self.assertTrue("CN=g3,%s" % self.ou_groups in dn_list)
1528 self.assertTrue("CN=g4,%s" % self.ou_groups in dn_list)
1529
1530 res1 = self.ldb.search(self.ou,
1531 scope=SCOPE_SUBTREE,
1532 expression=("(|(member:1.2.840.113556.1.4.1941:=cn=c2,%s)"
1533 "(member:1.2.840.113556.1.4.1941:=cn=c3,%s))") % (
1534 self.ou_computers, self.ou_computers))
1535 self.assertEqual(len(res1), 5)
1536 dn_list = [str(res.dn) for res in res1]
1537 self.assertTrue("CN=u1,%s" % self.ou_users in dn_list)
1538 self.assertTrue("CN=u2,%s" % self.ou_users in dn_list)
1539 self.assertTrue("CN=g1,%s" % self.ou_groups in dn_list)
1540 self.assertTrue("CN=g2,%s" % self.ou_groups in dn_list)
1541 self.assertTrue("CN=g3,%s" % self.ou_groups in dn_list)
1542
1543 res1 = self.ldb.search(self.ou,
1544 scope=SCOPE_SUBTREE,
1545 expression=("(|(member:1.2.840.113556.1.4.1941:=cn=c2,%s)"
1546 "(member:1.2.840.113556.1.4.1941:=cn=c4,%s))") % (
1547 self.ou_computers, self.ou_computers))
1548 self.assertEqual(len(res1), 3)
1549 dn_list = [str(res.dn) for res in res1]
1550 self.assertTrue("CN=u1,%s" % self.ou_users in dn_list)
1551 self.assertTrue("CN=u4,%s" % self.ou_users in dn_list)
1552 self.assertTrue("CN=g4,%s" % self.ou_groups in dn_list)
1553
1554 res1 = self.ldb.search(self.ou,
1555 scope=SCOPE_SUBTREE,
1556 expression=("(|(member:1.2.840.113556.1.4.1941:=cn=c3,%s)"
1557 "(member:1.2.840.113556.1.4.1941:=cn=c4,%s))") % (
1558 self.ou_computers, self.ou_computers))
1559 self.assertEqual(len(res1), 6)
1560 dn_list = [str(res.dn) for res in res1]
1561 self.assertTrue("CN=u2,%s" % self.ou_users in dn_list)
1562 self.assertTrue("CN=u4,%s" % self.ou_users in dn_list)
1563 self.assertTrue("CN=g1,%s" % self.ou_groups in dn_list)
1564 self.assertTrue("CN=g2,%s" % self.ou_groups in dn_list)
1565 self.assertTrue("CN=g3,%s" % self.ou_groups in dn_list)
1566 self.assertTrue("CN=g4,%s" % self.ou_groups in dn_list)
1567
1568 res1 = self.ldb.search(self.ou,
1569 scope=SCOPE_SUBTREE,
1570 expression=("(|(member:1.2.840.113556.1.4.1941:=cn=u1,%s)"
1571 "(member:1.2.840.113556.1.4.1941:=cn=c4,%s))") % (
1572 self.ou_users, self.ou_computers))
1573 self.assertEqual(len(res1), 2)
1574 dn_list = [str(res.dn) for res in res1]
1575 self.assertTrue("CN=u4,%s" % self.ou_users in dn_list)
1576 self.assertTrue("CN=g4,%s" % self.ou_groups in dn_list)
1577
1578 def test_and_member_queries(self):
1579 res1 = self.ldb.search(self.ou,
1580 scope=SCOPE_SUBTREE,
1581 expression=("(&(member:1.2.840.113556.1.4.1941:=cn=c1,%s)"
1582 "(member:1.2.840.113556.1.4.1941:=cn=c2,%s))") % (
1583 self.ou_computers, self.ou_computers))
1584 self.assertEqual(len(res1), 1)
1585 self.assertEqual(str(res1[0].dn), "CN=u1,%s" % self.ou_users)
1586
1587 res1 = self.ldb.search(self.ou,
1588 scope=SCOPE_SUBTREE,
1589 expression=("(&(member:1.2.840.113556.1.4.1941:=cn=c2,%s)"
1590 "(member:1.2.840.113556.1.4.1941:=cn=c3,%s))") % (
1591 self.ou_computers, self.ou_computers))
1592 self.assertEqual(len(res1), 0)
1593
1594 res1 = self.ldb.search(self.ou,
1595 scope=SCOPE_SUBTREE,
1596 expression=("(&(member:1.2.840.113556.1.4.1941:=cn=c3,%s)"
1597 "(member:1.2.840.113556.1.4.1941:=cn=u3,%s))") % (
1598 self.ou_computers, self.ou_users))
1599 self.assertEqual(len(res1), 3)
1600 dn_list = [str(res.dn) for res in res1]
1601 self.assertTrue("CN=g1,%s" % self.ou_groups in dn_list)
1602 self.assertTrue("CN=g2,%s" % self.ou_groups in dn_list)
1603 self.assertTrue("CN=g3,%s" % self.ou_groups in dn_list)
1604
1605 res1 = self.ldb.search(self.ou,
1606 scope=SCOPE_SUBTREE,
1607 expression=("(&(member:1.2.840.113556.1.4.1941:=cn=c1,%s)"
1608 "(member:1.2.840.113556.1.4.1941:=cn=u4,%s))") % (
1609 self.ou_computers, self.ou_computers))
1610 self.assertEqual(len(res1), 0)
1611
1612 def test_or_memberOf_queries(self):
1613 res1 = self.ldb.search(self.ou,
1614 scope=SCOPE_SUBTREE,
1615 expression=("(|(memberOf:1.2.840.113556.1.4.1941:=cn=g1,%s)"
1616 "(memberOf:1.2.840.113556.1.4.1941:=cn=g2,%s))") % (
1617 self.ou_groups, self.ou_groups))
1618 self.assertEqual(len(res1), 6)
1619 dn_list = [str(res.dn) for res in res1]
1620 self.assertTrue("CN=u2,%s" % self.ou_users in dn_list)
1621 self.assertTrue("CN=u3,%s" % self.ou_users in dn_list)
1622 self.assertTrue("CN=g2,%s" % self.ou_groups in dn_list)
1623 self.assertTrue("CN=g3,%s" % self.ou_groups in dn_list)
1624 self.assertTrue("CN=c1,%s" % self.ou_computers in dn_list)
1625 self.assertTrue("CN=c3,%s" % self.ou_computers in dn_list)
1626
1627 res1 = self.ldb.search(self.ou,
1628 scope=SCOPE_SUBTREE,
1629 expression=("(|(memberOf:1.2.840.113556.1.4.1941:=cn=g1,%s)"
1630 "(memberOf:1.2.840.113556.1.4.1941:=cn=g3,%s))") % (
1631 self.ou_groups, self.ou_groups))
1632 self.assertEqual(len(res1), 6)
1633 dn_list = [str(res.dn) for res in res1]
1634 self.assertTrue("CN=u2,%s" % self.ou_users in dn_list)
1635 self.assertTrue("CN=u3,%s" % self.ou_users in dn_list)
1636 self.assertTrue("CN=g2,%s" % self.ou_groups in dn_list)
1637 self.assertTrue("CN=g3,%s" % self.ou_groups in dn_list)
1638 self.assertTrue("CN=c1,%s" % self.ou_computers in dn_list)
1639 self.assertTrue("CN=c3,%s" % self.ou_computers in dn_list)
1640
1641 res1 = self.ldb.search(self.ou,
1642 scope=SCOPE_SUBTREE,
1643 expression=("(|(memberOf:1.2.840.113556.1.4.1941:=cn=g1,%s)"
1644 "(memberOf:1.2.840.113556.1.4.1941:=cn=g4,%s))") % (
1645 self.ou_groups, self.ou_groups))
1646 self.assertEqual(len(res1), 8)
1647 dn_list = [str(res.dn) for res in res1]
1648 self.assertTrue("CN=u2,%s" % self.ou_users in dn_list)
1649 self.assertTrue("CN=u3,%s" % self.ou_users in dn_list)
1650 self.assertTrue("CN=u4,%s" % self.ou_users in dn_list)
1651 self.assertTrue("CN=g2,%s" % self.ou_groups in dn_list)
1652 self.assertTrue("CN=g3,%s" % self.ou_groups in dn_list)
1653 self.assertTrue("CN=c1,%s" % self.ou_computers in dn_list)
1654 self.assertTrue("CN=c3,%s" % self.ou_computers in dn_list)
1655 self.assertTrue("CN=c4,%s" % self.ou_computers in dn_list)
1656
1657 res1 = self.ldb.search(self.ou,
1658 scope=SCOPE_SUBTREE,
1659 expression=("(|(memberOf:1.2.840.113556.1.4.1941:=cn=g2,%s)"
1660 "(memberOf:1.2.840.113556.1.4.1941:=cn=g3,%s))") %
1661 (self.ou_groups, self.ou_groups))
1662 self.assertEqual(len(res1), 5)
1663 dn_list = [str(res.dn) for res in res1]
1664 self.assertTrue("CN=u2,%s" % self.ou_users in dn_list)
1665 self.assertTrue("CN=u3,%s" % self.ou_users in dn_list)
1666 self.assertTrue("CN=g3,%s" % self.ou_groups in dn_list)
1667 self.assertTrue("CN=c1,%s" % self.ou_computers in dn_list)
1668 self.assertTrue("CN=c3,%s" % self.ou_computers in dn_list)
1669
1670 res1 = self.ldb.search(self.ou,
1671 scope=SCOPE_SUBTREE,
1672 expression=("(|(memberOf:1.2.840.113556.1.4.1941:=cn=g2,%s)"
1673 "(memberOf:1.2.840.113556.1.4.1941:=cn=g4,%s))") % (
1674 self.ou_groups, self.ou_groups))
1675 self.assertEqual(len(res1), 7)
1676 dn_list = [str(res.dn) for res in res1]
1677 self.assertTrue("CN=u2,%s" % self.ou_users in dn_list)
1678 self.assertTrue("CN=u3,%s" % self.ou_users in dn_list)
1679 self.assertTrue("CN=u4,%s" % self.ou_users in dn_list)
1680 self.assertTrue("CN=g3,%s" % self.ou_groups in dn_list)
1681 self.assertTrue("CN=c1,%s" % self.ou_computers in dn_list)
1682 self.assertTrue("CN=c3,%s" % self.ou_computers in dn_list)
1683 self.assertTrue("CN=c4,%s" % self.ou_computers in dn_list)
1684
1685 res1 = self.ldb.search(self.ou,
1686 scope=SCOPE_SUBTREE,
1687 expression=("(|(memberOf:1.2.840.113556.1.4.1941:=cn=g3,%s)"
1688 "(memberOf:1.2.840.113556.1.4.1941:=cn=g4,%s))") % (
1689 self.ou_groups, self.ou_groups))
1690 self.assertEqual(len(res1), 5)
1691 dn_list = [str(res.dn) for res in res1]
1692 self.assertTrue("CN=u3,%s" % self.ou_users in dn_list)
1693 self.assertTrue("CN=u4,%s" % self.ou_users in dn_list)
1694 self.assertTrue("CN=c1,%s" % self.ou_computers in dn_list)
1695 self.assertTrue("CN=c3,%s" % self.ou_computers in dn_list)
1696 self.assertTrue("CN=c4,%s" % self.ou_computers in dn_list)
1697
1698 def test_and_memberOf_queries(self):
1699 res1 = self.ldb.search(self.ou,
1700 scope=SCOPE_SUBTREE,
1701 expression=("(&(memberOf:1.2.840.113556.1.4.1941:=cn=g1,%s)"
1702 "(memberOf:1.2.840.113556.1.4.1941:=cn=g2,%s))") % (
1703 self.ou_groups, self.ou_groups))
1704 self.assertEqual(len(res1), 5)
1705 dn_list = [str(res.dn) for res in res1]
1706 self.assertTrue("CN=u2,%s" % self.ou_users in dn_list)
1707 self.assertTrue("CN=u3,%s" % self.ou_users in dn_list)
1708 self.assertTrue("CN=g3,%s" % self.ou_groups in dn_list)
1709 self.assertTrue("CN=c1,%s" % self.ou_computers in dn_list)
1710 self.assertTrue("CN=c3,%s" % self.ou_computers in dn_list)
1711
1712 res1 = self.ldb.search(self.ou,
1713 scope=SCOPE_SUBTREE,
1714 expression=("(&(memberOf:1.2.840.113556.1.4.1941:=cn=g1,%s)"
1715 "(memberOf:1.2.840.113556.1.4.1941:=cn=g3,%s))") % (
1716 self.ou_groups, self.ou_groups))
1717 self.assertEqual(len(res1), 3)
1718 dn_list = [str(res.dn) for res in res1]
1719 self.assertTrue("CN=u3,%s" % self.ou_users in dn_list)
1720 self.assertTrue("CN=c1,%s" % self.ou_computers in dn_list)
1721 self.assertTrue("CN=c3,%s" % self.ou_computers in dn_list)
1722
1723 res1 = self.ldb.search(self.ou,
1724 scope=SCOPE_SUBTREE,
1725 expression=("(&(memberOf:1.2.840.113556.1.4.1941:=cn=g1,%s)"
1726 "(memberOf:1.2.840.113556.1.4.1941:=cn=g4,%s))") % (
1727 self.ou_groups, self.ou_groups))
1728 self.assertEqual(len(res1), 2)
1729 dn_list = [str(res.dn) for res in res1]
1730 self.assertTrue("CN=u3,%s" % self.ou_users in dn_list)
1731 self.assertTrue("CN=c1,%s" % self.ou_computers in dn_list)
1732
1733 res1 = self.ldb.search(self.ou,
1734 scope=SCOPE_SUBTREE,
1735 expression=("(&(memberOf:1.2.840.113556.1.4.1941:=cn=g2,%s)"
1736 "(memberOf:1.2.840.113556.1.4.1941:=cn=g3,%s))") % (
1737 self.ou_groups, self.ou_groups))
1738 self.assertEqual(len(res1), 3)
1739 dn_list = [str(res.dn) for res in res1]
1740 self.assertTrue("CN=u3,%s" % self.ou_users in dn_list)
1741 self.assertTrue("CN=c1,%s" % self.ou_computers in dn_list)
1742 self.assertTrue("CN=c3,%s" % self.ou_computers in dn_list)
1743
1744 res1 = self.ldb.search(self.ou,
1745 scope=SCOPE_SUBTREE,
1746 expression=("(&(memberOf:1.2.840.113556.1.4.1941:=cn=g2,%s)"
1747 "(memberOf:1.2.840.113556.1.4.1941:=cn=g4,%s))") % (
1748 self.ou_groups, self.ou_groups))
1749 self.assertEqual(len(res1), 2)
1750 dn_list = [str(res.dn) for res in res1]
1751 self.assertTrue("CN=u3,%s" % self.ou_users in dn_list)
1752 self.assertTrue("CN=c1,%s" % self.ou_computers in dn_list)
1753
1754 res1 = self.ldb.search(self.ou,
1755 scope=SCOPE_SUBTREE,
1756 expression=("(&(memberOf:1.2.840.113556.1.4.1941:=cn=g3,%s)"
1757 "(memberOf:1.2.840.113556.1.4.1941:=cn=g4,%s))") % (
1758 self.ou_groups, self.ou_groups))
1759 self.assertEqual(len(res1), 2)
1760 dn_list = [str(res.dn) for res in res1]
1761 self.assertTrue("CN=u3,%s" % self.ou_users in dn_list)
1762 self.assertTrue("CN=c1,%s" % self.ou_computers in dn_list)
1763
1764 res1 = self.ldb.search(self.ou,
1765 scope=SCOPE_SUBTREE,
1766 expression=("(&(memberOf:1.2.840.113556.1.4.1941:=cn=g1,%s)"
1767 "(memberOf:1.2.840.113556.1.4.1941:=cn=c1,%s))") % (
1768 self.ou_groups, self.ou_computers))
1769 self.assertEqual(len(res1), 0)
1770
1771 if __name__ == "__main__":
1772
1773 parser = optparse.OptionParser("match_rules.py [options] <host>")
1774 sambaopts = options.SambaOptions(parser)
1775 parser.add_option_group(sambaopts)
1776 parser.add_option_group(options.VersionOptions(parser))
1777
1778 # use command line creds if available
1779 credopts = options.CredentialsOptions(parser)
1780 parser.add_option_group(credopts)
1781 opts, args = parser.parse_args()
1782 subunitopts = SubunitOptions(parser)
1783 parser.add_option_group(subunitopts)
1784
1785 if len(args) < 1:
1786 parser.print_usage()
1787 sys.exit(1)
1788
1789 host = args[0]
1790
1791 if "://" not in host:
1792 if os.path.isfile(host):
1793 host = "tdb://%s" % host
1794 else:
1795 host = "ldap://%s" % host
1796
1797 TestProgram(module=__name__, opts=subunitopts)