lib/ldb-samba/tests/match_rules.py

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