lib/ldb-samba/tests/match_rules.py

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