#!/usr/bin/python
# Unix SMB/CIFS implementation.
-# Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2005-2007
+# Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2005-2008
# Copyright (C) Martin Kuehl <mkhl@samba.org> 2006
#
# This is a Python port of the original in testprogs/ejs/samba3sam.js
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
+"""Tests for the samba3sam LDB module, which maps Samba3 LDAP to AD LDAP."""
+
import os
-import sys
-import samba
import ldb
+from ldb import SCOPE_DEFAULT, SCOPE_BASE, SCOPE_SUBTREE
from samba import Ldb, substitute_var
-from samba.tests import LdbTestCase, TestCaseInTempDir
+from samba.tests import LdbTestCase, TestCaseInTempDir, cmdline_loadparm
+import samba.dcerpc.dom_sid
+import samba.security
+import samba.ndr
-datadir = sys.argv[2]
+datadir = os.path.join(os.path.dirname(__file__),
+ "../../../../../testdata/samba3")
-class Samba3SamTestCase(TestCaseInTempDir):
- def setup_data(self, obj, ldif):
- self.assertTrue(ldif is not None)
- obj.db.add_ldif(substitute_var(ldif, obj.substvars))
+def read_datafile(filename):
+ return open(os.path.join(datadir, filename), 'r').read()
- def setup_modules(self, ldb, s3, s4, ldif):
- self.assertTrue(ldif is not None)
- ldb.add_ldif(substitute_var(ldif, s4.substvars))
+def ldb_debug(l, text):
+ print text
- ldif = """
-dn: @MAP=samba3sam
-@FROM: """ + s4.substvars["BASEDN"] + """
-@TO: sambaDomainName=TESTS,""" + s3.substvars["BASEDN"] + """
-
-dn: @MODULES
-@LIST: rootdse,paged_results,server_sort,extended_dn,asq,samldb,password_hash,operational,objectguid,rdn_name,samba3sam,partition
-
-dn: @PARTITION
-partition: """ + s4.substvars["BASEDN"] + ":" + s4.url + """
-partition: """ + s3.substvars["BASEDN"] + ":" + s3.url + """
-replicateEntries: @SUBCLASSES
-replicateEntries: @ATTRIBUTES
-replicateEntries: @INDEXLIST
-"""
- ldb.add_ldif(ldif)
- def test_s3sam_search(self, ldb):
- print "Looking up by non-mapped attribute"
- msg = ldb.search(expression="(cn=Administrator)")
+class MapBaseTestCase(TestCaseInTempDir):
+ """Base test case for mapping tests."""
+
+ def setup_modules(self, ldb, s3, s4):
+ ldb.add({"dn": "@MAP=samba3sam",
+ "@FROM": s4.basedn,
+ "@TO": "sambaDomainName=TESTS," + s3.basedn})
+
+ ldb.add({"dn": "@MODULES",
+ "@LIST": "rootdse,paged_results,server_sort,extended_dn,asq,samldb,password_hash,operational,objectguid,rdn_name,samba3sam,partition"})
+
+ ldb.add({"dn": "@PARTITION",
+ "partition": ["%s:%s" % (s4.basedn, s4.url),
+ "%s:%s" % (s3.basedn, s3.url)],
+ "replicateEntries": ["@ATTRIBUTES", "@INDEXLIST"]})
+
+ def setUp(self):
+ super(MapBaseTestCase, self).setUp()
+
+ def make_dn(basedn, rdn):
+ return "%s,sambaDomainName=TESTS,%s" % (rdn, basedn)
+
+ def make_s4dn(basedn, rdn):
+ return "%s,%s" % (rdn, basedn)
+
+ self.ldbfile = os.path.join(self.tempdir, "test.ldb")
+ self.ldburl = "tdb://" + self.ldbfile
+
+ tempdir = self.tempdir
+
+ class Target:
+ """Simple helper class that contains data for a specific SAM
+ connection."""
+ def __init__(self, file, basedn, dn):
+ self.file = os.path.join(tempdir, file)
+ self.url = "tdb://" + self.file
+ self.basedn = basedn
+ self.substvars = {"BASEDN": self.basedn}
+ self.db = Ldb(lp=cmdline_loadparm)
+ self._dn = dn
+
+ def dn(self, rdn):
+ return self._dn(self.basedn, rdn)
+
+ def connect(self):
+ return self.db.connect(self.url)
+
+ def setup_data(self, path):
+ self.add_ldif(read_datafile(path))
+
+ def subst(self, text):
+ return substitute_var(text, self.substvars)
+
+ def add_ldif(self, ldif):
+ self.db.add_ldif(self.subst(ldif))
+
+ def modify_ldif(self, ldif):
+ self.db.modify_ldif(self.subst(ldif))
+
+ self.samba4 = Target("samba4.ldb", "dc=vernstok,dc=nl", make_s4dn)
+ self.samba3 = Target("samba3.ldb", "cn=Samba3Sam", make_dn)
+ self.templates = Target("templates.ldb", "cn=templates", None)
+
+ self.samba3.connect()
+ self.templates.connect()
+ self.samba4.connect()
+
+ def tearDown(self):
+ os.unlink(self.ldbfile)
+ os.unlink(self.samba3.file)
+ os.unlink(self.templates.file)
+ os.unlink(self.samba4.file)
+ super(MapBaseTestCase, self).tearDown()
+
+ def assertSidEquals(self, text, ndr_sid):
+ sid_obj1 = samba.ndr.ndr_unpack(samba.dcerpc.dom_sid.dom_sid,
+ str(ndr_sid[0]))
+ sid_obj2 = samba.security.Sid(text)
+ # For now, this is the only way we can compare these since the
+ # classes are in different places. Should reconcile that at some point.
+ self.assertEquals(sid_obj1.sid_rev_num, sid_obj2.sid_rev_num)
+ self.assertEquals(sid_obj1.num_auths, sid_obj2.num_auths)
+ # FIXME: self.assertEquals(sid_obj1.id_auth, sid_obj2.id_auth)
+ # FIXME: self.assertEquals(sid_obj1.sub_auths[:sid_obj1.num_auths],
+ # sid_obj2.sub_auths[:sid_obj2.num_auths])
+
+
+class Samba3SamTestCase(MapBaseTestCase):
+
+ def setUp(self):
+ super(Samba3SamTestCase, self).setUp()
+ ldb = Ldb(self.ldburl, lp=cmdline_loadparm)
+ self.samba3.setup_data("samba3.ldif")
+ self.templates.setup_data("provision_samba3sam_templates.ldif")
+ ldif = read_datafile("provision_samba3sam.ldif")
+ ldb.add_ldif(self.samba4.subst(ldif))
+ self.setup_modules(ldb, self.samba3, self.samba4)
+ del ldb
+ self.ldb = Ldb(self.ldburl, lp=cmdline_loadparm)
+
+ def test_search_non_mapped(self):
+ """Looking up by non-mapped attribute"""
+ msg = self.ldb.search(expression="(cn=Administrator)")
self.assertEquals(len(msg), 1)
self.assertEquals(msg[0]["cn"], "Administrator")
- print "Looking up by mapped attribute"
- msg = ldb.search(expression="(name=Backup Operators)")
+ def test_search_non_mapped(self):
+ """Looking up by mapped attribute"""
+ msg = self.ldb.search(expression="(name=Backup Operators)")
self.assertEquals(len(msg), 1)
self.assertEquals(msg[0]["name"], "Backup Operators")
- print "Looking up by old name of renamed attribute"
- msg = ldb.search(expression="(displayName=Backup Operators)")
+ def test_old_name_of_renamed(self):
+ """Looking up by old name of renamed attribute"""
+ msg = self.ldb.search(expression="(displayName=Backup Operators)")
self.assertEquals(len(msg), 0)
- print "Looking up mapped entry containing SID"
- msg = ldb.search(expression="(cn=Replicator)")
+ def test_mapped_containing_sid(self):
+ """Looking up mapped entry containing SID"""
+ msg = self.ldb.search(expression="(cn=Replicator)")
self.assertEquals(len(msg), 1)
- print msg[0].dn
- self.assertEquals(str(msg[0].dn), "cn=Replicator,ou=Groups,dc=vernstok,dc=nl")
- self.assertEquals(msg[0]["objectSid"], "S-1-5-21-4231626423-2410014848-2360679739-552")
-
- print "Checking mapping of objectClass"
+ self.assertEquals(str(msg[0].dn),
+ "cn=Replicator,ou=Groups,dc=vernstok,dc=nl")
+ self.assertTrue("objectSid" in msg[0])
+ self.assertSidEquals("S-1-5-21-4231626423-2410014848-2360679739-552",
+ msg[0]["objectSid"])
oc = set(msg[0]["objectClass"])
- self.assertTrue(oc is not None)
- for i in oc:
- self.assertEquals(oc[i] == "posixGroup" or oc[i], "group")
-
- print "Looking up by objectClass"
- msg = ldb.search(expression="(|(objectClass=user)(cn=Administrator))")
- self.assertEquals(len(msg), 2)
- for i in range(len(msg)):
- self.assertEquals((str(msg[i].dn), "unixName=Administrator,ou=Users,dc=vernstok,dc=nl") or
- (str(msg[i].dn) == "unixName=nobody,ou=Users,dc=vernstok,dc=nl"))
-
-
- def test_s3sam_modify(ldb, s3):
- print "Adding a record that will be fallbacked"
- ldb.add_ldif("""
-dn: cn=Foo
-foo: bar
-blah: Blie
-cn: Foo
-showInAdvancedViewOnly: TRUE
- """)
-
- print "Checking for existence of record (local)"
- # TODO: This record must be searched in the local database, which is currently only supported for base searches
+ self.assertEquals(oc, set(["group"]))
+
+ def test_search_by_objclass(self):
+ """Looking up by objectClass"""
+ msg = self.ldb.search(expression="(|(objectClass=user)(cn=Administrator))")
+ self.assertEquals(set([str(m.dn) for m in msg]),
+ set(["unixName=Administrator,ou=Users,dc=vernstok,dc=nl",
+ "unixName=nobody,ou=Users,dc=vernstok,dc=nl"]))
+
+ def test_s3sam_modify(self):
+ # Adding a record that will be fallbacked
+ self.ldb.add({"dn": "cn=Foo",
+ "foo": "bar",
+ "blah": "Blie",
+ "cn": "Foo",
+ "showInAdvancedViewOnly": "TRUE"}
+ )
+
+ # Checking for existence of record (local)
+ # TODO: This record must be searched in the local database, which is
+ # currently only supported for base searches
# msg = ldb.search(expression="(cn=Foo)", ['foo','blah','cn','showInAdvancedViewOnly')]
# TODO: Actually, this version should work as well but doesn't...
#
#
- attrs = ['foo','blah','cn','showInAdvancedViewOnly']
- msg = ldb.search(expression="(cn=Foo)", base="cn=Foo", scope=ldb.LDB_SCOPE_BASE, attrs=attrs)
+ msg = self.ldb.search(expression="(cn=Foo)", base="cn=Foo",
+ scope=SCOPE_BASE,
+ attrs=['foo','blah','cn','showInAdvancedViewOnly'])
self.assertEquals(len(msg), 1)
self.assertEquals(msg[0]["showInAdvancedViewOnly"], "TRUE")
self.assertEquals(msg[0]["foo"], "bar")
self.assertEquals(msg[0]["blah"], "Blie")
- print "Adding record that will be mapped"
- ldb.add_ldif("""
-dn: cn=Niemand,cn=Users,dc=vernstok,dc=nl
-objectClass: user
-unixName: bin
-sambaUnicodePwd: geheim
-cn: Niemand
-""")
+ # Adding record that will be mapped
+ self.ldb.add({"dn": "cn=Niemand,cn=Users,dc=vernstok,dc=nl",
+ "objectClass": "user",
+ "unixName": "bin",
+ "sambaUnicodePwd": "geheim",
+ "cn": "Niemand"})
- print "Checking for existence of record (remote)"
- msg = ldb.search(expression="(unixName=bin)", attrs=['unixName','cn','dn', 'sambaUnicodePwd'])
+ # Checking for existence of record (remote)
+ msg = self.ldb.search(expression="(unixName=bin)",
+ attrs=['unixName','cn','dn', 'sambaUnicodePwd'])
self.assertEquals(len(msg), 1)
self.assertEquals(msg[0]["cn"], "Niemand")
self.assertEquals(msg[0]["sambaUnicodePwd"], "geheim")
- print "Checking for existence of record (local && remote)"
- msg = ldb.search(expression="(&(unixName=bin)(sambaUnicodePwd=geheim))",
+ # Checking for existence of record (local && remote)
+ msg = self.ldb.search(expression="(&(unixName=bin)(sambaUnicodePwd=geheim))",
attrs=['unixName','cn','dn', 'sambaUnicodePwd'])
self.assertEquals(len(msg), 1) # TODO: should check with more records
self.assertEquals(msg[0]["cn"], "Niemand")
self.assertEquals(msg[0]["unixName"], "bin")
self.assertEquals(msg[0]["sambaUnicodePwd"], "geheim")
- print "Checking for existence of record (local || remote)"
- msg = ldb.search(expression="(|(unixName=bin)(sambaUnicodePwd=geheim))",
+ # Checking for existence of record (local || remote)
+ msg = self.ldb.search(expression="(|(unixName=bin)(sambaUnicodePwd=geheim))",
attrs=['unixName','cn','dn', 'sambaUnicodePwd'])
- print "got " + len(msg) + " replies"
+ #print "got %d replies" % len(msg)
self.assertEquals(len(msg), 1) # TODO: should check with more records
self.assertEquals(msg[0]["cn"], "Niemand")
- self.assertEquals(msg[0]["unixName"] == "bin" or msg[0]["sambaUnicodePwd"], "geheim")
+ self.assertEquals(msg[0]["unixName"], "bin")
+ self.assertEquals(msg[0]["sambaUnicodePwd"], "geheim")
- print "Checking for data in destination database"
- msg = s3.db.search("(cn=Niemand)")
+ # Checking for data in destination database
+ msg = self.samba3.db.search(expression="(cn=Niemand)")
self.assertTrue(len(msg) >= 1)
- self.assertEquals(msg[0]["sambaSID"], "S-1-5-21-4231626423-2410014848-2360679739-2001")
+ self.assertEquals(msg[0]["sambaSID"],
+ "S-1-5-21-4231626423-2410014848-2360679739-2001")
self.assertEquals(msg[0]["displayName"], "Niemand")
- print "Adding attribute..."
- ldb.modify_ldif("""
+ # Adding attribute...
+ self.ldb.modify_ldif("""
dn: cn=Niemand,cn=Users,dc=vernstok,dc=nl
changetype: modify
add: description
description: Blah
""")
- print "Checking whether changes are still there..."
- msg = ldb.search(expression="(cn=Niemand)")
+ # Checking whether changes are still there...
+ msg = self.ldb.search(expression="(cn=Niemand)")
self.assertTrue(len(msg) >= 1)
self.assertEquals(msg[0]["cn"], "Niemand")
self.assertEquals(msg[0]["description"], "Blah")
- print "Modifying attribute..."
- ldb.modify_ldif("""
+ # Modifying attribute...
+ self.ldb.modify_ldif("""
dn: cn=Niemand,cn=Users,dc=vernstok,dc=nl
changetype: modify
replace: description
description: Blie
""")
- print "Checking whether changes are still there..."
- msg = ldb.search(expression="(cn=Niemand)")
+ # Checking whether changes are still there...
+ msg = self.ldb.search(expression="(cn=Niemand)")
self.assertTrue(len(msg) >= 1)
self.assertEquals(msg[0]["description"], "Blie")
- print "Deleting attribute..."
- ldb.modify_ldif("""
+ # Deleting attribute...
+ self.ldb.modify_ldif("""
dn: cn=Niemand,cn=Users,dc=vernstok,dc=nl
changetype: modify
delete: description
""")
- print "Checking whether changes are no longer there..."
- msg = ldb.search(expression="(cn=Niemand)")
+ # Checking whether changes are no longer there...
+ msg = self.ldb.search(expression="(cn=Niemand)")
self.assertTrue(len(msg) >= 1)
- self.assertEquals(msg[0]["description"], undefined)
+ self.assertTrue(not "description" in msg[0])
- print "Renaming record..."
- ldb.rename("cn=Niemand,cn=Users,dc=vernstok,dc=nl", "cn=Niemand2,cn=Users,dc=vernstok,dc=nl")
+ # Renaming record...
+ self.ldb.rename("cn=Niemand,cn=Users,dc=vernstok,dc=nl",
+ "cn=Niemand2,cn=Users,dc=vernstok,dc=nl")
- print "Checking whether DN has changed..."
- msg = ldb.search(expression="(cn=Niemand2)")
+ # Checking whether DN has changed...
+ msg = self.ldb.search(expression="(cn=Niemand2)")
self.assertEquals(len(msg), 1)
- self.assertEquals(str(msg[0].dn), "cn=Niemand2,cn=Users,dc=vernstok,dc=nl")
+ self.assertEquals(str(msg[0].dn),
+ "cn=Niemand2,cn=Users,dc=vernstok,dc=nl")
- print "Deleting record..."
- ldb.delete("cn=Niemand2,cn=Users,dc=vernstok,dc=nl")
+ # Deleting record...
+ self.ldb.delete("cn=Niemand2,cn=Users,dc=vernstok,dc=nl")
- print "Checking whether record is gone..."
- msg = ldb.search(expression="(cn=Niemand2)")
+ # Checking whether record is gone...
+ msg = self.ldb.search(expression="(cn=Niemand2)")
self.assertEquals(len(msg), 0)
- def test_map_search(ldb, s3, s4):
- print "Running search tests on mapped data"
- ldif = """
-dn: """ + "sambaDomainName=TESTS,""" + s3.substvars["BASEDN"] + """
-objectclass: sambaDomain
-objectclass: top
-sambaSID: S-1-5-21-4231626423-2410014848-2360679739
-sambaNextRid: 2000
-sambaDomainName: TESTS"""
- self.assertTrue(ldif is not None)
- s3.db.add_ldif(substitute_var(ldif, s3.substvars))
-
- print "Add a set of split records"
- ldif = """
-dn: """ + s4.dn("cn=X") + """
+
+class MapTestCase(MapBaseTestCase):
+
+ def setUp(self):
+ super(MapTestCase, self).setUp()
+ ldb = Ldb(self.ldburl, lp=cmdline_loadparm)
+ self.templates.setup_data("provision_samba3sam_templates.ldif")
+ ldif = read_datafile("provision_samba3sam.ldif")
+ ldb.add_ldif(self.samba4.subst(ldif))
+ self.setup_modules(ldb, self.samba3, self.samba4)
+ del ldb
+ self.ldb = Ldb(self.ldburl, lp=cmdline_loadparm)
+
+ def test_map_search(self):
+ """Running search tests on mapped data."""
+ self.samba3.db.add({
+ "dn": "sambaDomainName=TESTS," + self.samba3.basedn,
+ "objectclass": ["sambaDomain", "top"],
+ "sambaSID": "S-1-5-21-4231626423-2410014848-2360679739",
+ "sambaNextRid": "2000",
+ "sambaDomainName": "TESTS"
+ })
+
+ # Add a set of split records
+ self.ldb.add_ldif("""
+dn: """+ self.samba4.dn("cn=X") + """
objectClass: user
cn: X
codePage: x
objectSid: S-1-5-21-4231626423-2410014848-2360679739-552
primaryGroupID: 1-5-21-4231626423-2410014848-2360679739-512
-dn: """ + s4.dn("cn=Y") + """
-objectClass: top
-cn: Y
-codePage: x
-revision: x
-dnsHostName: y
-nextRid: y
-lastLogon: y
-description: x
-
-dn: """ + s4.dn("cn=Z") + """
-objectClass: top
-cn: Z
-codePage: x
-revision: y
-dnsHostName: z
-nextRid: y
-lastLogon: z
-description: y
-"""
-
- self.assertTrue(ldif is not None)
- ldb.add_ldif(substitute_var(ldif, s4.substvars))
-
- print "Add a set of remote records"
-
- ldif = """
-dn: """ + s3.dn("cn=A") + """
-objectClass: posixAccount
-cn: A
-sambaNextRid: x
-sambaBadPasswordCount: x
-sambaLogonTime: x
-description: x
-sambaSID: S-1-5-21-4231626423-2410014848-2360679739-552
-sambaPrimaryGroupSID: S-1-5-21-4231626423-2410014848-2360679739-512
-
-dn: """ + s3.dn("cn=B") + """
-objectClass: top
-cn:B
-sambaNextRid: x
-sambaBadPasswordCount: x
-sambaLogonTime: y
-description: x
-
-dn: """ + s3.dn("cn=C") + """
-objectClass: top
-cn: C
-sambaNextRid: x
-sambaBadPasswordCount: y
-sambaLogonTime: z
-description: y
-"""
- self.assertTrue(ldif is not None)
- s3.add_ldif(substitute_var(ldif, s3.substvars))
+""")
- print "Testing search by DN"
+ self.ldb.add({
+ "dn": self.samba4.dn("cn=Y"),
+ "objectClass": "top",
+ "cn": "Y",
+ "codePage": "x",
+ "revision": "x",
+ "dnsHostName": "y",
+ "nextRid": "y",
+ "lastLogon": "y",
+ "description": "x"})
+
+ self.ldb.add({
+ "dn": self.samba4.dn("cn=Z"),
+ "objectClass": "top",
+ "cn": "Z",
+ "codePage": "x",
+ "revision": "y",
+ "dnsHostName": "z",
+ "nextRid": "y",
+ "lastLogon": "z",
+ "description": "y"})
+
+ # Add a set of remote records
+
+ self.samba3.db.add({
+ "dn": self.samba3.dn("cn=A"),
+ "objectClass": "posixAccount",
+ "cn": "A",
+ "sambaNextRid": "x",
+ "sambaBadPasswordCount": "x",
+ "sambaLogonTime": "x",
+ "description": "x",
+ "sambaSID": "S-1-5-21-4231626423-2410014848-2360679739-552",
+ "sambaPrimaryGroupSID": "S-1-5-21-4231626423-2410014848-2360679739-512"})
+
+ self.samba3.db.add({
+ "dn": self.samba3.dn("cn=B"),
+ "objectClass": "top",
+ "cn": "B",
+ "sambaNextRid": "x",
+ "sambaBadPasswordCount": "x",
+ "sambaLogonTime": "y",
+ "description": "x"})
+
+ self.samba3.db.add({
+ "dn": self.samba3.dn("cn=C"),
+ "objectClass": "top",
+ "cn": "C",
+ "sambaNextRid": "x",
+ "sambaBadPasswordCount": "y",
+ "sambaLogonTime": "z",
+ "description": "y"})
+
+ # Testing search by DN
# Search remote record by local DN
- dn = s4.dn("cn=A")
- attrs = ["dnsHostName", "lastLogon"]
- res = ldb.search(dn, scope=ldb.SCOPE_BASE, attrs=attrs)
+ dn = self.samba4.dn("cn=A")
+ res = self.ldb.search(dn, scope=SCOPE_BASE,
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 1)
- self.assertEquals(str(str(res[0].dn)), dn)
- self.assertEquals(res[0]["dnsHostName"], undefined)
+ self.assertEquals(str(res[0].dn), dn)
+ self.assertTrue(not "dnsHostName" in res[0])
self.assertEquals(res[0]["lastLogon"], "x")
# Search remote record by remote DN
- dn = s3.dn("cn=A")
- attrs = ["dnsHostName", "lastLogon", "sambaLogonTime"]
- res = s3.db.search(dn, scope=ldb.SCOPE_BASE, attrs=attrs)
+ dn = self.samba3.dn("cn=A")
+ res = self.samba3.db.search(dn, scope=SCOPE_BASE,
+ attrs=["dnsHostName", "lastLogon", "sambaLogonTime"])
self.assertEquals(len(res), 1)
- self.assertEquals(str(str(res[0].dn)), dn)
- self.assertEquals(res[0]["dnsHostName"], undefined)
- self.assertEquals(res[0]["lastLogon"], undefined)
+ self.assertEquals(str(res[0].dn), dn)
+ self.assertTrue(not "dnsHostName" in res[0])
+ self.assertTrue(not "lastLogon" in res[0])
self.assertEquals(res[0]["sambaLogonTime"], "x")
# Search split record by local DN
- dn = s4.dn("cn=X")
- attrs = ["dnsHostName", "lastLogon"]
- res = ldb.search(dn, scope=ldb.SCOPE_BASE, attrs=attrs)
+ dn = self.samba4.dn("cn=X")
+ res = self.ldb.search(dn, scope=SCOPE_BASE,
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 1)
- self.assertEquals(str(str(res[0].dn)), dn)
+ self.assertEquals(str(res[0].dn), dn)
self.assertEquals(res[0]["dnsHostName"], "x")
self.assertEquals(res[0]["lastLogon"], "x")
# Search split record by remote DN
- dn = s3.dn("cn=X")
- attrs = ["dnsHostName", "lastLogon", "sambaLogonTime"]
- res = s3.db.search(dn, scope=ldb.SCOPE_BASE, attrs=attrs)
+ dn = self.samba3.dn("cn=X")
+ res = self.samba3.db.search(dn, scope=SCOPE_BASE,
+ attrs=["dnsHostName", "lastLogon", "sambaLogonTime"])
self.assertEquals(len(res), 1)
- self.assertEquals(str(str(res[0].dn)), dn)
- self.assertEquals(res[0]["dnsHostName"], undefined)
- self.assertEquals(res[0]["lastLogon"], undefined)
+ self.assertEquals(str(res[0].dn), dn)
+ self.assertTrue(not "dnsHostName" in res[0])
+ self.assertTrue(not "lastLogon" in res[0])
self.assertEquals(res[0]["sambaLogonTime"], "x")
- print "Testing search by attribute"
+ # Testing search by attribute
# Search by ignored attribute
- attrs = ["dnsHostName", "lastLogon"]
- res = ldb.search(expression="(revision=x)", scope=ldb.SCOPE_DEFAULT, attrs=attrs)
+ res = self.ldb.search(expression="(revision=x)", scope=SCOPE_DEFAULT,
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 2)
- self.assertEquals(str(str(res[0].dn)), s4.dn("cn=Y"))
+ self.assertEquals(str(res[0].dn), self.samba4.dn("cn=Y"))
self.assertEquals(res[0]["dnsHostName"], "y")
self.assertEquals(res[0]["lastLogon"], "y")
- self.assertEquals(str(str(res[1].dn)), s4.dn("cn=X"))
+ self.assertEquals(str(res[1].dn), self.samba4.dn("cn=X"))
self.assertEquals(res[1]["dnsHostName"], "x")
self.assertEquals(res[1]["lastLogon"], "x")
# Search by kept attribute
- attrs = ["dnsHostName", "lastLogon"]
- res = ldb.search(expression="(description=y)", scope=ldb.SCOPE_DEFAULT, attrs=attrs)
+ res = self.ldb.search(expression="(description=y)",
+ scope=SCOPE_DEFAULT, attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 2)
- self.assertEquals(str(str(res[0].dn)), s4.dn("cn=Z"))
+ self.assertEquals(str(res[0].dn), self.samba4.dn("cn=Z"))
self.assertEquals(res[0]["dnsHostName"], "z")
self.assertEquals(res[0]["lastLogon"], "z")
- self.assertEquals(str(str(res[1].dn)), s4.dn("cn=C"))
- self.assertEquals(res[1]["dnsHostName"], undefined)
+ self.assertEquals(str(res[1].dn), self.samba4.dn("cn=C"))
+ self.assertTrue(not "dnsHostName" in res[1])
self.assertEquals(res[1]["lastLogon"], "z")
# Search by renamed attribute
- attrs = ["dnsHostName", "lastLogon"]
- res = ldb.search(expression="(badPwdCount=x)", scope=ldb.SCOPE_DEFAULT, attrs=attrs)
+ res = self.ldb.search(expression="(badPwdCount=x)", scope=SCOPE_DEFAULT,
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 2)
- self.assertEquals(str(res[0].dn), s4.dn("cn=B"))
- self.assertEquals(res[0]["dnsHostName"], undefined)
+ self.assertEquals(str(res[0].dn), self.samba4.dn("cn=B"))
+ self.assertTrue(not "dnsHostName" in res[0])
self.assertEquals(res[0]["lastLogon"], "y")
- self.assertEquals(str(res[1].dn), s4.dn("cn=A"))
- self.assertEquals(res[1]["dnsHostName"], undefined)
+ self.assertEquals(str(res[1].dn), self.samba4.dn("cn=A"))
+ self.assertTrue(not "dnsHostName" in res[1])
self.assertEquals(res[1]["lastLogon"], "x")
# Search by converted attribute
- attrs = ["dnsHostName", "lastLogon", "objectSid"]
# TODO:
# Using the SID directly in the parse tree leads to conversion
# errors, letting the search fail with no results.
- #res = ldb.search("(objectSid=S-1-5-21-4231626423-2410014848-2360679739-552)", NULL, ldb. SCOPE_DEFAULT, attrs)
- res = ldb.search(expression="(objectSid=*)", attrs=attrs)
+ #res = self.ldb.search("(objectSid=S-1-5-21-4231626423-2410014848-2360679739-552)", scope=SCOPE_DEFAULT, attrs)
+ res = self.ldb.search(expression="(objectSid=*)", base=None, scope=SCOPE_DEFAULT, attrs=["dnsHostName", "lastLogon", "objectSid"])
self.assertEquals(len(res), 3)
- self.assertEquals(str(res[0].dn), s4.dn("cn=X"))
+ self.assertEquals(str(res[0].dn), self.samba4.dn("cn=X"))
self.assertEquals(res[0]["dnsHostName"], "x")
self.assertEquals(res[0]["lastLogon"], "x")
- self.assertEquals(res[0]["objectSid"], "S-1-5-21-4231626423-2410014848-2360679739-552")
- self.assertEquals(str(res[1].dn), s4.dn("cn=A"))
- self.assertEquals(res[1]["dnsHostName"], undefined)
+ self.assertSidEquals("S-1-5-21-4231626423-2410014848-2360679739-552",
+ res[0]["objectSid"])
+ self.assertTrue("objectSid" in res[0])
+ self.assertEquals(str(res[1].dn), self.samba4.dn("cn=A"))
+ self.assertTrue(not "dnsHostName" in res[1])
self.assertEquals(res[1]["lastLogon"], "x")
- self.assertEquals(res[1]["objectSid"], "S-1-5-21-4231626423-2410014848-2360679739-552")
+ self.assertSidEquals("S-1-5-21-4231626423-2410014848-2360679739-552",
+ res[1]["objectSid"])
+ self.assertTrue("objectSid" in res[1])
# Search by generated attribute
# In most cases, this even works when the mapping is missing
# a `convert_operator' by enumerating the remote db.
- attrs = ["dnsHostName", "lastLogon", "primaryGroupID"]
- res = ldb.search(expression="(primaryGroupID=512)", attrs=attrs)
+ res = self.ldb.search(expression="(primaryGroupID=512)",
+ attrs=["dnsHostName", "lastLogon", "primaryGroupID"])
self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), s4.dn("cn=A"))
- self.assertEquals(res[0]["dnsHostName"], undefined)
+ self.assertEquals(str(res[0].dn), self.samba4.dn("cn=A"))
+ self.assertTrue(not "dnsHostName" in res[0])
self.assertEquals(res[0]["lastLogon"], "x")
self.assertEquals(res[0]["primaryGroupID"], "512")
#
# Search by remote name of renamed attribute */
- attrs = ["dnsHostName", "lastLogon"]
- res = ldb.search(expression="(sambaBadPasswordCount=*)", attrs=attrs)
+ res = self.ldb.search(expression="(sambaBadPasswordCount=*)",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 0)
# Search by objectClass
attrs = ["dnsHostName", "lastLogon", "objectClass"]
- res = ldb.search(expression="(objectClass=user)", attrs=attrs)
+ res = self.ldb.search(expression="(objectClass=user)", attrs=attrs)
self.assertEquals(len(res), 2)
- self.assertEquals(str(res[0].dn), s4.dn("cn=X"))
+ self.assertEquals(str(res[0].dn), self.samba4.dn("cn=X"))
self.assertEquals(res[0]["dnsHostName"], "x")
self.assertEquals(res[0]["lastLogon"], "x")
- self.assertTrue(res[0]["objectClass"] is not None)
self.assertEquals(res[0]["objectClass"][0], "user")
- self.assertEquals(str(res[1].dn), s4.dn("cn=A"))
- self.assertEquals(res[1]["dnsHostName"], undefined)
+ self.assertEquals(str(res[1].dn), self.samba4.dn("cn=A"))
+ self.assertTrue(not "dnsHostName" in res[1])
self.assertEquals(res[1]["lastLogon"], "x")
- self.assertTrue(res[1]["objectClass"] is not None)
self.assertEquals(res[1]["objectClass"][0], "user")
# Prove that the objectClass is actually used for the search
- res = ldb.search(expression="(|(objectClass=user)(badPwdCount=x))", attrs=attrs)
+ res = self.ldb.search(expression="(|(objectClass=user)(badPwdCount=x))",
+ attrs=attrs)
self.assertEquals(len(res), 3)
- self.assertEquals(str(res[0].dn), s4.dn("cn=B"))
- self.assertEquals(res[0]["dnsHostName"], undefined)
+ self.assertEquals(str(res[0].dn), self.samba4.dn("cn=B"))
+ self.assertTrue(not "dnsHostName" in res[0])
self.assertEquals(res[0]["lastLogon"], "y")
- self.assertTrue(res[0]["objectClass"] is not None)
- for oc in set(res[0]["objectClass"]):
- self.assertEquals(oc, "user")
- self.assertEquals(str(res[1].dn), s4.dn("cn=X"))
+ self.assertEquals(set(res[0]["objectClass"]), set(["top"]))
+ self.assertEquals(str(res[1].dn), self.samba4.dn("cn=X"))
self.assertEquals(res[1]["dnsHostName"], "x")
self.assertEquals(res[1]["lastLogon"], "x")
- self.assertTrue(res[1]["objectClass"] is not None)
self.assertEquals(res[1]["objectClass"][0], "user")
- self.assertEquals(str(res[2].dn), s4.dn("cn=A"))
- self.assertEquals(res[2]["dnsHostName"], undefined)
+ self.assertEquals(str(res[2].dn), self.samba4.dn("cn=A"))
+ self.assertTrue(not "dnsHostName" in res[2])
self.assertEquals(res[2]["lastLogon"], "x")
- self.assertTrue(res[2]["objectClass"] is not None)
self.assertEquals(res[2]["objectClass"][0], "user")
- print "Testing search by parse tree"
+ # Testing search by parse tree
# Search by conjunction of local attributes
- attrs = ["dnsHostName", "lastLogon"]
- res = ldb.search(expression="(&(codePage=x)(revision=x))", attrs=attrs)
+ res = self.ldb.search(expression="(&(codePage=x)(revision=x))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 2)
- self.assertEquals(str(res[0].dn), s4.dn("cn=Y"))
+ self.assertEquals(str(res[0].dn), self.samba4.dn("cn=Y"))
self.assertEquals(res[0]["dnsHostName"], "y")
self.assertEquals(res[0]["lastLogon"], "y")
- self.assertEquals(str(res[1].dn), s4.dn("cn=X"))
+ self.assertEquals(str(res[1].dn), self.samba4.dn("cn=X"))
self.assertEquals(res[1]["dnsHostName"], "x")
self.assertEquals(res[1]["lastLogon"], "x")
# Search by conjunction of remote attributes
- attrs = ["dnsHostName", "lastLogon"]
- res = ldb.search(expression="(&(lastLogon=x)(description=x))", attrs=attrs)
+ res = self.ldb.search(expression="(&(lastLogon=x)(description=x))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 2)
- self.assertEquals(str(res[0].dn), s4.dn("cn=X"))
+ self.assertEquals(str(res[0].dn), self.samba4.dn("cn=X"))
self.assertEquals(res[0]["dnsHostName"], "x")
self.assertEquals(res[0]["lastLogon"], "x")
- self.assertEquals(str(res[1].dn), s4.dn("cn=A"))
- self.assertEquals(res[1]["dnsHostName"], undefined)
+ self.assertEquals(str(res[1].dn), self.samba4.dn("cn=A"))
+ self.assertTrue(not "dnsHostName" in res[1])
self.assertEquals(res[1]["lastLogon"], "x")
# Search by conjunction of local and remote attribute
- attrs = ["dnsHostName", "lastLogon"]
- res = ldb.search(expression="(&(codePage=x)(description=x))", attrs=attrs)
+ res = self.ldb.search(expression="(&(codePage=x)(description=x))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 2)
- self.assertEquals(str(res[0].dn), s4.dn("cn=Y"))
+ self.assertEquals(str(res[0].dn), self.samba4.dn("cn=Y"))
self.assertEquals(res[0]["dnsHostName"], "y")
self.assertEquals(res[0]["lastLogon"], "y")
- self.assertEquals(str(res[1].dn), s4.dn("cn=X"))
+ self.assertEquals(str(res[1].dn), self.samba4.dn("cn=X"))
self.assertEquals(res[1]["dnsHostName"], "x")
self.assertEquals(res[1]["lastLogon"], "x")
# Search by conjunction of local and remote attribute w/o match
attrs = ["dnsHostName", "lastLogon"]
- res = ldb.search(expression="(&(codePage=x)(nextRid=x))", attrs=attrs)
+ res = self.ldb.search(expression="(&(codePage=x)(nextRid=x))",
+ attrs=attrs)
self.assertEquals(len(res), 0)
- res = ldb.search(expression="(&(revision=x)(lastLogon=z))", attrs=attrs)
+ res = self.ldb.search(expression="(&(revision=x)(lastLogon=z))",
+ attrs=attrs)
self.assertEquals(len(res), 0)
# Search by disjunction of local attributes
- attrs = ["dnsHostName", "lastLogon"]
- res = ldb.search(expression="(|(revision=x)(dnsHostName=x))", attrs=attrs)
+ res = self.ldb.search(expression="(|(revision=x)(dnsHostName=x))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 2)
- self.assertEquals(str(res[0].dn), s4.dn("cn=Y"))
+ self.assertEquals(str(res[0].dn), self.samba4.dn("cn=Y"))
self.assertEquals(res[0]["dnsHostName"], "y")
self.assertEquals(res[0]["lastLogon"], "y")
- self.assertEquals(str(res[1].dn), s4.dn("cn=X"))
+ self.assertEquals(str(res[1].dn), self.samba4.dn("cn=X"))
self.assertEquals(res[1]["dnsHostName"], "x")
self.assertEquals(res[1]["lastLogon"], "x")
# Search by disjunction of remote attributes
- attrs = ["dnsHostName", "lastLogon"]
- res = ldb.search(expression="(|(badPwdCount=x)(lastLogon=x))", attrs=attrs)
+ res = self.ldb.search(expression="(|(badPwdCount=x)(lastLogon=x))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 3)
- self.assertEquals(str(res[0].dn), s4.dn("cn=B"))
- self.assertEquals(res[0]["dnsHostName"], undefined)
+ self.assertEquals(str(res[0].dn), self.samba4.dn("cn=B"))
+ self.assertFalse("dnsHostName" in res[0])
self.assertEquals(res[0]["lastLogon"], "y")
- self.assertEquals(str(res[1].dn), s4.dn("cn=X"))
+ self.assertEquals(str(res[1].dn), self.samba4.dn("cn=X"))
self.assertEquals(res[1]["dnsHostName"], "x")
self.assertEquals(res[1]["lastLogon"], "x")
- self.assertEquals(str(res[2].dn), s4.dn("cn=A"))
- self.assertEquals(res[2]["dnsHostName"], undefined)
+ self.assertEquals(str(res[2].dn), self.samba4.dn("cn=A"))
+ self.assertFalse("dnsHostName" in res[2])
self.assertEquals(res[2]["lastLogon"], "x")
# Search by disjunction of local and remote attribute
- attrs = ["dnsHostName", "lastLogon"]
- res = ldb.search(expression="(|(revision=x)(lastLogon=y))", attrs=attrs)
+ res = self.ldb.search(expression="(|(revision=x)(lastLogon=y))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 3)
- self.assertEquals(str(res[0].dn), s4.dn("cn=Y"))
+ self.assertEquals(str(res[0].dn), self.samba4.dn("cn=Y"))
self.assertEquals(res[0]["dnsHostName"], "y")
self.assertEquals(res[0]["lastLogon"], "y")
- self.assertEquals(str(res[1].dn), s4.dn("cn=B"))
- self.assertEquals(res[1]["dnsHostName"], undefined)
+ self.assertEquals(str(res[1].dn), self.samba4.dn("cn=B"))
+ self.assertFalse("dnsHostName" in res[1])
self.assertEquals(res[1]["lastLogon"], "y")
- self.assertEquals(str(res[2].dn), s4.dn("cn=X"))
+ self.assertEquals(str(res[2].dn), self.samba4.dn("cn=X"))
self.assertEquals(res[2]["dnsHostName"], "x")
self.assertEquals(res[2]["lastLogon"], "x")
# Search by disjunction of local and remote attribute w/o match
- attrs = ["dnsHostName", "lastLogon"]
- res = ldb.search(expression="(|(codePage=y)(nextRid=z))", attrs=attrs)
+ res = self.ldb.search(expression="(|(codePage=y)(nextRid=z))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 0)
# Search by negated local attribute
- attrs = ["dnsHostName", "lastLogon"]
- res = ldb.search(expression="(!(revision=x))", attrs=attrs)
+ res = self.ldb.search(expression="(!(revision=x))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 5)
- self.assertEquals(str(res[0].dn), s4.dn("cn=B"))
- self.assertEquals(res[0]["dnsHostName"], undefined)
+ self.assertEquals(str(res[0].dn), self.samba4.dn("cn=B"))
+ self.assertTrue(not "dnsHostName" in res[0])
self.assertEquals(res[0]["lastLogon"], "y")
- self.assertEquals(str(res[1].dn), s4.dn("cn=A"))
- self.assertEquals(res[1]["dnsHostName"], undefined)
+ self.assertEquals(str(res[1].dn), self.samba4.dn("cn=A"))
+ self.assertTrue(not "dnsHostName" in res[1])
self.assertEquals(res[1]["lastLogon"], "x")
- self.assertEquals(str(res[2].dn), s4.dn("cn=Z"))
+ self.assertEquals(str(res[2].dn), self.samba4.dn("cn=Z"))
self.assertEquals(res[2]["dnsHostName"], "z")
self.assertEquals(res[2]["lastLogon"], "z")
- self.assertEquals(str(res[3].dn), s4.dn("cn=C"))
- self.assertEquals(res[3]["dnsHostName"], undefined)
+ self.assertEquals(str(res[3].dn), self.samba4.dn("cn=C"))
+ self.assertTrue(not "dnsHostName" in res[3])
self.assertEquals(res[3]["lastLogon"], "z")
# Search by negated remote attribute
- attrs = ["dnsHostName", "lastLogon"]
- res = ldb.search(expression="(!(description=x))", attrs=attrs)
+ res = self.ldb.search(expression="(!(description=x))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 3)
- self.assertEquals(str(res[0].dn), s4.dn("cn=Z"))
+ self.assertEquals(str(res[0].dn), self.samba4.dn("cn=Z"))
self.assertEquals(res[0]["dnsHostName"], "z")
self.assertEquals(res[0]["lastLogon"], "z")
- self.assertEquals(str(res[1].dn), s4.dn("cn=C"))
- self.assertEquals(res[1]["dnsHostName"], undefined)
+ self.assertEquals(str(res[1].dn), self.samba4.dn("cn=C"))
+ self.assertTrue(not "dnsHostName" in res[1])
self.assertEquals(res[1]["lastLogon"], "z")
# Search by negated conjunction of local attributes
- attrs = ["dnsHostName", "lastLogon"]
- res = ldb.search(expression="(!(&(codePage=x)(revision=x)))", attrs=attrs)
+ res = self.ldb.search(expression="(!(&(codePage=x)(revision=x)))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 5)
- self.assertEquals(str(res[0].dn), s4.dn("cn=B"))
- self.assertEquals(res[0]["dnsHostName"], undefined)
+ self.assertEquals(str(res[0].dn), self.samba4.dn("cn=B"))
+ self.assertTrue(not "dnsHostName" in res[0])
self.assertEquals(res[0]["lastLogon"], "y")
- self.assertEquals(str(res[1].dn), s4.dn("cn=A"))
- self.assertEquals(res[1]["dnsHostName"], undefined)
+ self.assertEquals(str(res[1].dn), self.samba4.dn("cn=A"))
+ self.assertTrue(not "dnsHostName" in res[1])
self.assertEquals(res[1]["lastLogon"], "x")
- self.assertEquals(str(res[2].dn), s4.dn("cn=Z"))
+ self.assertEquals(str(res[2].dn), self.samba4.dn("cn=Z"))
self.assertEquals(res[2]["dnsHostName"], "z")
self.assertEquals(res[2]["lastLogon"], "z")
- self.assertEquals(str(res[3].dn), s4.dn("cn=C"))
- self.assertEquals(res[3]["dnsHostName"], undefined)
+ self.assertEquals(str(res[3].dn), self.samba4.dn("cn=C"))
+ self.assertTrue(not "dnsHostName" in res[3])
self.assertEquals(res[3]["lastLogon"], "z")
# Search by negated conjunction of remote attributes
- attrs = ["dnsHostName", "lastLogon"]
- res = ldb.search(expression="(!(&(lastLogon=x)(description=x)))", attrs=attrs)
+ res = self.ldb.search(expression="(!(&(lastLogon=x)(description=x)))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 5)
- self.assertEquals(str(res[0].dn), s4.dn("cn=Y"))
+ self.assertEquals(str(res[0].dn), self.samba4.dn("cn=Y"))
self.assertEquals(res[0]["dnsHostName"], "y")
self.assertEquals(res[0]["lastLogon"], "y")
- self.assertEquals(str(res[1].dn), s4.dn("cn=B"))
- self.assertEquals(res[1]["dnsHostName"], undefined)
+ self.assertEquals(str(res[1].dn), self.samba4.dn("cn=B"))
+ self.assertTrue(not "dnsHostName" in res[1])
self.assertEquals(res[1]["lastLogon"], "y")
- self.assertEquals(str(res[2].dn), s4.dn("cn=Z"))
+ self.assertEquals(str(res[2].dn), self.samba4.dn("cn=Z"))
self.assertEquals(res[2]["dnsHostName"], "z")
self.assertEquals(res[2]["lastLogon"], "z")
- self.assertEquals(str(res[3].dn), s4.dn("cn=C"))
- self.assertEquals(res[3]["dnsHostName"], undefined)
+ self.assertEquals(str(res[3].dn), self.samba4.dn("cn=C"))
+ self.assertTrue(not "dnsHostName" in res[3])
self.assertEquals(res[3]["lastLogon"], "z")
# Search by negated conjunction of local and remote attribute
- attrs = ["dnsHostName", "lastLogon"]
- res = ldb.search(expression="(!(&(codePage=x)(description=x)))", attrs=attrs)
+ res = self.ldb.search(expression="(!(&(codePage=x)(description=x)))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 5)
- self.assertEquals(str(res[0].dn), s4.dn("cn=B"))
- self.assertEquals(res[0]["dnsHostName"], undefined)
+ self.assertEquals(str(res[0].dn), self.samba4.dn("cn=B"))
+ self.assertTrue(not "dnsHostName" in res[0])
self.assertEquals(res[0]["lastLogon"], "y")
- self.assertEquals(str(res[1].dn), s4.dn("cn=A"))
- self.assertEquals(res[1]["dnsHostName"], undefined)
+ self.assertEquals(str(res[1].dn), self.samba4.dn("cn=A"))
+ self.assertTrue(not "dnsHostName" in res[1])
self.assertEquals(res[1]["lastLogon"], "x")
- self.assertEquals(str(res[2].dn), s4.dn("cn=Z"))
+ self.assertEquals(str(res[2].dn), self.samba4.dn("cn=Z"))
self.assertEquals(res[2]["dnsHostName"], "z")
self.assertEquals(res[2]["lastLogon"], "z")
- self.assertEquals(str(res[3].dn), s4.dn("cn=C"))
- self.assertEquals(res[3]["dnsHostName"], undefined)
+ self.assertEquals(str(res[3].dn), self.samba4.dn("cn=C"))
+ self.assertTrue(not "dnsHostName" in res[3])
self.assertEquals(res[3]["lastLogon"], "z")
# Search by negated disjunction of local attributes
- attrs = ["dnsHostName", "lastLogon"]
- res = ldb.search(expression="(!(|(revision=x)(dnsHostName=x)))", attrs=attrs)
- self.assertEquals(str(res[0].dn), s4.dn("cn=B"))
- self.assertEquals(res[0]["dnsHostName"], undefined)
+ res = self.ldb.search(expression="(!(|(revision=x)(dnsHostName=x)))",
+ attrs=["dnsHostName", "lastLogon"])
+ self.assertEquals(str(res[0].dn), self.samba4.dn("cn=B"))
+ self.assertTrue(not "dnsHostName" in res[0])
self.assertEquals(res[0]["lastLogon"], "y")
- self.assertEquals(str(res[1].dn), s4.dn("cn=A"))
- self.assertEquals(res[1]["dnsHostName"], undefined)
+ self.assertEquals(str(res[1].dn), self.samba4.dn("cn=A"))
+ self.assertTrue(not "dnsHostName" in res[1])
self.assertEquals(res[1]["lastLogon"], "x")
- self.assertEquals(str(res[2].dn), s4.dn("cn=Z"))
+ self.assertEquals(str(res[2].dn), self.samba4.dn("cn=Z"))
self.assertEquals(res[2]["dnsHostName"], "z")
self.assertEquals(res[2]["lastLogon"], "z")
- self.assertEquals(str(res[3].dn), s4.dn("cn=C"))
- self.assertEquals(res[3]["dnsHostName"], undefined)
+ self.assertEquals(str(res[3].dn), self.samba4.dn("cn=C"))
+ self.assertTrue(not "dnsHostName" in res[3])
self.assertEquals(res[3]["lastLogon"], "z")
# Search by negated disjunction of remote attributes
- attrs = ["dnsHostName", "lastLogon"]
- res = ldb.search(expression="(!(|(badPwdCount=x)(lastLogon=x)))", attrs=attrs)
+ res = self.ldb.search(expression="(!(|(badPwdCount=x)(lastLogon=x)))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 4)
- self.assertEquals(str(res[0].dn), s4.dn("cn=Y"))
+ self.assertEquals(str(res[0].dn), self.samba4.dn("cn=Y"))
self.assertEquals(res[0]["dnsHostName"], "y")
self.assertEquals(res[0]["lastLogon"], "y")
- self.assertEquals(str(res[1].dn), s4.dn("cn=Z"))
+ self.assertEquals(str(res[1].dn), self.samba4.dn("cn=Z"))
self.assertEquals(res[1]["dnsHostName"], "z")
self.assertEquals(res[1]["lastLogon"], "z")
- self.assertEquals(str(res[2].dn), s4.dn("cn=C"))
- self.assertEquals(res[2]["dnsHostName"], undefined)
+ self.assertEquals(str(res[2].dn), self.samba4.dn("cn=C"))
+ self.assertTrue(not "dnsHostName" in res[2])
self.assertEquals(res[2]["lastLogon"], "z")
# Search by negated disjunction of local and remote attribute
- attrs = ["dnsHostName", "lastLogon"]
- res = ldb.search(expression="(!(|(revision=x)(lastLogon=y)))", attrs=attrs)
+ res = self.ldb.search(expression="(!(|(revision=x)(lastLogon=y)))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 4)
- self.assertEquals(str(res[0].dn), s4.dn("cn=A"))
- self.assertEquals(res[0]["dnsHostName"], undefined)
+ self.assertEquals(str(res[0].dn), self.samba4.dn("cn=A"))
+ self.assertTrue(not "dnsHostName" in res[0])
self.assertEquals(res[0]["lastLogon"], "x")
- self.assertEquals(str(res[1].dn), s4.dn("cn=Z"))
+ self.assertEquals(str(res[1].dn), self.samba4.dn("cn=Z"))
self.assertEquals(res[1]["dnsHostName"], "z")
self.assertEquals(res[1]["lastLogon"], "z")
- self.assertEquals(str(res[2].dn), s4.dn("cn=C"))
- self.assertEquals(res[2]["dnsHostName"], undefined)
+ self.assertEquals(str(res[2].dn), self.samba4.dn("cn=C"))
+ self.assertTrue(not "dnsHostName" in res[2])
self.assertEquals(res[2]["lastLogon"], "z")
- print "Search by complex parse tree"
- attrs = ["dnsHostName", "lastLogon"]
- res = ldb.search(expression="(|(&(revision=x)(dnsHostName=x))(!(&(description=x)(nextRid=y)))(badPwdCount=y))", attrs=attrs)
+ # Search by complex parse tree
+ res = self.ldb.search(expression="(|(&(revision=x)(dnsHostName=x))(!(&(description=x)(nextRid=y)))(badPwdCount=y))", attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 6)
- self.assertEquals(str(res[0].dn), s4.dn("cn=B"))
- self.assertEquals(res[0]["dnsHostName"], undefined)
+ self.assertEquals(str(res[0].dn), self.samba4.dn("cn=B"))
+ self.assertTrue(not "dnsHostName" in res[0])
self.assertEquals(res[0]["lastLogon"], "y")
- self.assertEquals(str(res[1].dn), s4.dn("cn=X"))
+ self.assertEquals(str(res[1].dn), self.samba4.dn("cn=X"))
self.assertEquals(res[1]["dnsHostName"], "x")
self.assertEquals(res[1]["lastLogon"], "x")
- self.assertEquals(str(res[2].dn), s4.dn("cn=A"))
- self.assertEquals(res[2]["dnsHostName"], undefined)
+ self.assertEquals(str(res[2].dn), self.samba4.dn("cn=A"))
+ self.assertTrue(not "dnsHostName" in res[2])
self.assertEquals(res[2]["lastLogon"], "x")
- self.assertEquals(str(res[3].dn), s4.dn("cn=Z"))
+ self.assertEquals(str(res[3].dn), self.samba4.dn("cn=Z"))
self.assertEquals(res[3]["dnsHostName"], "z")
self.assertEquals(res[3]["lastLogon"], "z")
- self.assertEquals(str(res[4].dn), s4.dn("cn=C"))
- self.assertEquals(res[4]["dnsHostName"], undefined)
+ self.assertEquals(str(res[4].dn), self.samba4.dn("cn=C"))
+ self.assertTrue(not "dnsHostName" in res[4])
self.assertEquals(res[4]["lastLogon"], "z")
# Clean up
- dns = [s4.dn("cn=%s" % n) for n in ["A","B","C","X","Y","Z"]]
+ dns = [self.samba4.dn("cn=%s" % n) for n in ["A","B","C","X","Y","Z"]]
for dn in dns:
- ldb.delete(dn)
-
- def test_map_modify(self, ldb, s3, s4):
- print "Running modification tests on mapped data"
-
- print "Testing modification of local records"
+ self.ldb.delete(dn)
+ def test_map_modify_local(self):
+ """Modification of local records."""
# Add local record
dn = "cn=test,dc=idealx,dc=org"
- ldif = """
-dn: """ + dn + """
-cn: test
-foo: bar
-revision: 1
-description: test
-"""
- ldb.add_ldif(ldif)
+ self.ldb.add({"dn": dn,
+ "cn": "test",
+ "foo": "bar",
+ "revision": "1",
+ "description": "test"})
# Check it's there
attrs = ["foo", "revision", "description"]
- res = ldb.search(dn, scope=ldb.SCOPE_BASE, attrs=attrs)
+ res = self.ldb.search(dn, scope=SCOPE_BASE, attrs=attrs)
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn)
self.assertEquals(res[0]["foo"], "bar")
self.assertEquals(res[0]["revision"], "1")
self.assertEquals(res[0]["description"], "test")
# Check it's not in the local db
- res = s4.db.search("(cn=test)", NULL, ldb.SCOPE_DEFAULT, attrs)
+ res = self.samba4.db.search(expression="(cn=test)",
+ scope=SCOPE_DEFAULT, attrs=attrs)
self.assertEquals(len(res), 0)
# Check it's not in the remote db
- res = s3.db.search("(cn=test)", NULL, ldb.SCOPE_DEFAULT, attrs)
+ res = self.samba3.db.search(expression="(cn=test)",
+ scope=SCOPE_DEFAULT, attrs=attrs)
self.assertEquals(len(res), 0)
# Modify local record
replace: description
description: foo
"""
- ldb.modify_ldif(ldif)
+ self.ldb.modify_ldif(ldif)
# Check in local db
- res = ldb.search(dn, scope=ldb.SCOPE_BASE, attrs=attrs)
+ res = self.ldb.search(dn, scope=SCOPE_BASE, attrs=attrs)
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn)
self.assertEquals(res[0]["foo"], "baz")
# Rename local record
dn2 = "cn=toast,dc=idealx,dc=org"
- ldb.rename(dn, dn2)
+ self.ldb.rename(dn, dn2)
# Check in local db
- res = ldb.search(dn2, scope=ldb.SCOPE_BASE, attrs=attrs)
+ res = self.ldb.search(dn2, scope=SCOPE_BASE, attrs=attrs)
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn2)
self.assertEquals(res[0]["foo"], "baz")
self.assertEquals(res[0]["description"], "foo")
# Delete local record
- ldb.delete(dn2)
+ self.ldb.delete(dn2)
# Check it's gone
- res = ldb.search(dn2, scope=ldb.SCOPE_BASE)
+ res = self.ldb.search(dn2, scope=SCOPE_BASE)
self.assertEquals(len(res), 0)
- print "Testing modification of remote records"
-
+ def test_map_modify_remote_remote(self):
+ """Modification of remote data of remote records"""
# Add remote record
- dn = s4.dn("cn=test")
- dn2 = s3.dn("cn=test")
- ldif = """
-dn: """ + dn2 + """
-cn: test
-description: foo
-sambaBadPasswordCount: 3
-sambaNextRid: 1001
-"""
- s3.db.add_ldif(ldif)
+ dn = self.samba4.dn("cn=test")
+ dn2 = self.samba3.dn("cn=test")
+ self.samba3.db.add({"dn": dn2,
+ "cn": "test",
+ "description": "foo",
+ "sambaBadPasswordCount": "3",
+ "sambaNextRid": "1001"})
# Check it's there
- attrs = ["description", "sambaBadPasswordCount", "sambaNextRid"]
- res = s3.db.search("", dn2, ldb.SCOPE_BASE, attrs)
+ res = self.samba3.db.search(dn2, scope=SCOPE_BASE,
+ attrs=["description", "sambaBadPasswordCount", "sambaNextRid"])
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn2)
self.assertEquals(res[0]["description"], "foo")
self.assertEquals(res[0]["sambaNextRid"], "1001")
# Check in mapped db
attrs = ["description", "badPwdCount", "nextRid"]
- res = ldb.search(dn, scope=ldb.SCOPE_BASE, attrs=attrs)
+ res = self.ldb.search(dn, scope=SCOPE_BASE, attrs=attrs, expression="")
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn)
self.assertEquals(res[0]["description"], "foo")
self.assertEquals(res[0]["badPwdCount"], "3")
self.assertEquals(res[0]["nextRid"], "1001")
# Check in local db
- res = s4.db.search("", dn, ldb.SCOPE_BASE, attrs)
+ res = self.samba4.db.search(dn, scope=SCOPE_BASE, attrs=attrs)
self.assertEquals(len(res), 0)
# Modify remote data of remote record
replace: badPwdCount
badPwdCount: 4
"""
- ldb.modify_ldif(ldif)
+ self.ldb.modify_ldif(ldif)
# Check in mapped db
- attrs = ["description", "badPwdCount", "nextRid"]
- res = ldb.search(dn, scope=ldb.SCOPE_BASE, attrs=attrs)
+ res = self.ldb.search(dn, scope=SCOPE_BASE,
+ attrs=["description", "badPwdCount", "nextRid"])
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn)
self.assertEquals(res[0]["description"], "test")
self.assertEquals(res[0]["badPwdCount"], "4")
self.assertEquals(res[0]["nextRid"], "1001")
# Check in remote db
- attrs = ["description", "sambaBadPasswordCount", "sambaNextRid"]
- res = s3.db.search("", dn2, ldb.SCOPE_BASE, attrs)
+ res = self.samba3.db.search(dn2, scope=SCOPE_BASE,
+ attrs=["description", "sambaBadPasswordCount", "sambaNextRid"])
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn2)
self.assertEquals(res[0]["description"], "test")
self.assertEquals(res[0]["sambaNextRid"], "1001")
# Rename remote record
- dn2 = s4.dn("cn=toast")
- ldb.rename(dn, dn2)
+ dn2 = self.samba4.dn("cn=toast")
+ self.ldb.rename(dn, dn2)
# Check in mapped db
dn = dn2
- attrs = ["description", "badPwdCount", "nextRid"]
- res = ldb.search(dn, scope=ldb.SCOPE_BASE, attrs=attrs)
+ res = self.ldb.search(dn, scope=SCOPE_BASE,
+ attrs=["description", "badPwdCount", "nextRid"])
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn)
self.assertEquals(res[0]["description"], "test")
self.assertEquals(res[0]["badPwdCount"], "4")
self.assertEquals(res[0]["nextRid"], "1001")
# Check in remote db
- dn2 = s3.dn("cn=toast")
- attrs = ["description", "sambaBadPasswordCount", "sambaNextRid"]
- res = s3.db.search("", dn2, ldb.SCOPE_BASE, attrs)
+ dn2 = self.samba3.dn("cn=toast")
+ res = self.samba3.db.search(dn2, scope=SCOPE_BASE,
+ attrs=["description", "sambaBadPasswordCount", "sambaNextRid"])
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn2)
self.assertEquals(res[0]["description"], "test")
self.assertEquals(res[0]["sambaNextRid"], "1001")
# Delete remote record
- ldb.delete(dn)
- # Check in mapped db
- res = ldb.search(dn, scope=ldb.SCOPE_BASE)
+ self.ldb.delete(dn)
+ # Check in mapped db that it's removed
+ res = self.ldb.search(dn, scope=SCOPE_BASE)
self.assertEquals(len(res), 0)
# Check in remote db
- res = s3.db.search("", dn2, ldb.SCOPE_BASE)
+ res = self.samba3.db.search(dn2, scope=SCOPE_BASE)
self.assertEquals(len(res), 0)
+ def test_map_modify_remote_local(self):
+ """Modification of local data of remote records"""
# Add remote record (same as before)
- dn = s4.dn("cn=test")
- dn2 = s3.dn("cn=test")
- ldif = """
-dn: """ + dn2 + """
-cn: test
-description: foo
-sambaBadPasswordCount: 3
-sambaNextRid: 1001
-"""
- s3.db.add_ldif(ldif)
+ dn = self.samba4.dn("cn=test")
+ dn2 = self.samba3.dn("cn=test")
+ self.samba3.db.add({"dn": dn2,
+ "cn": "test",
+ "description": "foo",
+ "sambaBadPasswordCount": "3",
+ "sambaNextRid": "1001"})
# Modify local data of remote record
ldif = """
revision: 1
replace: description
description: test
+
"""
- ldb.modify_ldif(ldif)
+ self.ldb.modify_ldif(ldif)
# Check in mapped db
attrs = ["revision", "description"]
- res = ldb.search(dn, scope=ldb.SCOPE_BASE, attrs=attrs)
+ res = self.ldb.search(dn, scope=SCOPE_BASE, attrs=attrs)
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn)
self.assertEquals(res[0]["description"], "test")
self.assertEquals(res[0]["revision"], "1")
# Check in remote db
- res = s3.db.search("", dn2, ldb.SCOPE_BASE, attrs)
+ res = self.samba3.db.search(dn2, scope=SCOPE_BASE, attrs=attrs)
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn2)
self.assertEquals(res[0]["description"], "test")
- self.assertEquals(res[0]["revision"], undefined)
+ self.assertTrue(not "revision" in res[0])
# Check in local db
- res = s4.db.search("", dn, ldb.SCOPE_BASE, attrs)
+ res = self.samba4.db.search(dn, scope=SCOPE_BASE, attrs=attrs)
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn)
- self.assertEquals(res[0]["description"], undefined)
+ self.assertTrue(not "description" in res[0])
self.assertEquals(res[0]["revision"], "1")
# Delete (newly) split record
- ldb.delete(dn)
-
- print "Testing modification of split records"
+ self.ldb.delete(dn)
+ def test_map_modify_split(self):
+ """Testing modification of split records"""
# Add split record
- dn = s4.dn("cn=test")
- dn2 = s3.dn("cn=test")
- ldif = """
-dn: """ + dn + """
-cn: test
-description: foo
-badPwdCount: 3
-nextRid: 1001
-revision: 1
-"""
- ldb.add_ldif(ldif)
+ dn = self.samba4.dn("cn=test")
+ dn2 = self.samba3.dn("cn=test")
+ self.ldb.add({
+ "dn": dn,
+ "cn": "test",
+ "description": "foo",
+ "badPwdCount": "3",
+ "nextRid": "1001",
+ "revision": "1"})
# Check it's there
attrs = ["description", "badPwdCount", "nextRid", "revision"]
- res = ldb.search(dn, scope=ldb.SCOPE_BASE, attrs=attrs)
+ res = self.ldb.search(dn, scope=SCOPE_BASE, attrs=attrs)
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn)
self.assertEquals(res[0]["description"], "foo")
self.assertEquals(res[0]["nextRid"], "1001")
self.assertEquals(res[0]["revision"], "1")
# Check in local db
- res = s4.db.search("", dn, ldb.SCOPE_BASE, attrs)
+ res = self.samba4.db.search(dn, scope=SCOPE_BASE, attrs=attrs)
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn)
- self.assertEquals(res[0]["description"], undefined)
- self.assertEquals(res[0]["badPwdCount"], undefined)
- self.assertEquals(res[0]["nextRid"], undefined)
+ self.assertTrue(not "description" in res[0])
+ self.assertTrue(not "badPwdCount" in res[0])
+ self.assertTrue(not "nextRid" in res[0])
self.assertEquals(res[0]["revision"], "1")
# Check in remote db
- attrs = ["description", "sambaBadPasswordCount", "sambaNextRid", "revision"]
- res = s3.db.search("", dn2, ldb.SCOPE_BASE, attrs)
+ attrs = ["description", "sambaBadPasswordCount", "sambaNextRid",
+ "revision"]
+ res = self.samba3.db.search(dn2, scope=SCOPE_BASE, attrs=attrs)
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn2)
self.assertEquals(res[0]["description"], "foo")
self.assertEquals(res[0]["sambaBadPasswordCount"], "3")
self.assertEquals(res[0]["sambaNextRid"], "1001")
- self.assertEquals(res[0]["revision"], undefined)
+ self.assertTrue(not "revision" in res[0])
# Modify of split record
ldif = """
replace: revision
revision: 2
"""
- ldb.modify_ldif(ldif)
+ self.ldb.modify_ldif(ldif)
# Check in mapped db
attrs = ["description", "badPwdCount", "nextRid", "revision"]
- res = ldb.search(dn, scope=ldb.SCOPE_BASE, attrs=attrs)
+ res = self.ldb.search(dn, scope=SCOPE_BASE, attrs=attrs)
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn)
self.assertEquals(res[0]["description"], "test")
self.assertEquals(res[0]["nextRid"], "1001")
self.assertEquals(res[0]["revision"], "2")
# Check in local db
- res = s4.db.search("", dn, ldb.SCOPE_BASE, attrs)
+ res = self.samba4.db.search(dn, scope=SCOPE_BASE, attrs=attrs)
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn)
- self.assertEquals(res[0]["description"], undefined)
- self.assertEquals(res[0]["badPwdCount"], undefined)
- self.assertEquals(res[0]["nextRid"], undefined)
+ self.assertTrue(not "description" in res[0])
+ self.assertTrue(not "badPwdCount" in res[0])
+ self.assertTrue(not "nextRid" in res[0])
self.assertEquals(res[0]["revision"], "2")
# Check in remote db
- attrs = ["description", "sambaBadPasswordCount", "sambaNextRid", "revision"]
- res = s3.db.search("", dn2, ldb.SCOPE_BASE, attrs)
+ attrs = ["description", "sambaBadPasswordCount", "sambaNextRid",
+ "revision"]
+ res = self.samba3.db.search(dn2, scope=SCOPE_BASE, attrs=attrs)
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn2)
self.assertEquals(res[0]["description"], "test")
self.assertEquals(res[0]["sambaBadPasswordCount"], "4")
self.assertEquals(res[0]["sambaNextRid"], "1001")
- self.assertEquals(res[0]["revision"], undefined)
+ self.assertTrue(not "revision" in res[0])
# Rename split record
- dn2 = s4.dn("cn=toast")
- ldb.rename(dn, dn2)
+ dn2 = self.samba4.dn("cn=toast")
+ self.ldb.rename(dn, dn2)
# Check in mapped db
dn = dn2
attrs = ["description", "badPwdCount", "nextRid", "revision"]
- res = ldb.search(dn, scope=ldb.SCOPE_BASE, attrs=attrs)
+ res = self.ldb.search(dn, scope=SCOPE_BASE, attrs=attrs)
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn)
self.assertEquals(res[0]["description"], "test")
self.assertEquals(res[0]["nextRid"], "1001")
self.assertEquals(res[0]["revision"], "2")
# Check in local db
- res = s4.db.search("", dn, ldb.SCOPE_BASE, attrs)
+ res = self.samba4.db.search(dn, scope=SCOPE_BASE, attrs=attrs)
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn)
- self.assertEquals(res[0]["description"], undefined)
- self.assertEquals(res[0]["badPwdCount"], undefined)
- self.assertEquals(res[0]["nextRid"], undefined)
+ self.assertTrue(not "description" in res[0])
+ self.assertTrue(not "badPwdCount" in res[0])
+ self.assertTrue(not "nextRid" in res[0])
self.assertEquals(res[0]["revision"], "2")
# Check in remote db
- dn2 = s3.dn("cn=toast")
- attrs = ["description", "sambaBadPasswordCount", "sambaNextRid", "revision"]
- res = s3.db.search("", dn2, ldb.SCOPE_BASE, attrs)
+ dn2 = self.samba3.dn("cn=toast")
+ res = self.samba3.db.search(dn2, scope=SCOPE_BASE,
+ attrs=["description", "sambaBadPasswordCount", "sambaNextRid",
+ "revision"])
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn2)
self.assertEquals(res[0]["description"], "test")
self.assertEquals(res[0]["sambaBadPasswordCount"], "4")
self.assertEquals(res[0]["sambaNextRid"], "1001")
- self.assertEquals(res[0]["revision"], undefined)
+ self.assertTrue(not "revision" in res[0])
# Delete split record
- ldb.delete(dn)
+ self.ldb.delete(dn)
# Check in mapped db
- res = ldb.search(dn, scope=ldb.SCOPE_BASE)
+ res = self.ldb.search(dn, scope=SCOPE_BASE)
self.assertEquals(len(res), 0)
# Check in local db
- res = s4.db.search("", dn, ldb.SCOPE_BASE)
+ res = self.samba4.db.search(dn, scope=SCOPE_BASE)
self.assertEquals(len(res), 0)
# Check in remote db
- res = s3.db.search("", dn2, ldb.SCOPE_BASE)
+ res = self.samba3.db.search(dn2, scope=SCOPE_BASE)
self.assertEquals(len(res), 0)
-
- def setUp(self):
- super(Samba3SamTestCase, self).setUp()
-
- def make_dn(rdn):
- return rdn + ",sambaDomainName=TESTS," + this.substvars["BASEDN"]
-
- def make_s4dn(rdn):
- return rdn + "," + this.substvars["BASEDN"]
-
- ldb = Ldb()
-
- ldbfile = os.path.join(self.tempdir, "test.ldb")
- ldburl = "tdb://" + ldbfile
-
- tempdir = self.tempdir
-
- class Target:
- def __init__(self, file, basedn, dn):
- self.file = os.path.join(tempdir, file)
- self.url = "tdb://" + self.file
- self.substvars = {"BASEDN": basedn}
- self.db = Ldb()
- self.dn = dn
-
- samba4 = Target("samba4.ldb", "dc=vernstok,dc=nl", make_s4dn)
- samba3 = Target("samba3.ldb", "cn=Samba3Sam", make_dn)
- templates = Target("templates.ldb", "cn=templates", None)
-
- ldb.connect(ldburl)
- samba3.db.connect(samba3.url)
- templates.db.connect(templates.url)
- samba4.db.connect(samba4.url)
-
- self.setup_data(samba3, open(os.path.join(datadir, "samba3.ldif"), 'r').read())
- self.setup_data(templates, open(os.path.join(datadir, "provision_samba3sam_templates.ldif"), 'r').read())
- self.setup_modules(ldb, samba3, samba4, open(os.path.join(datadir, "provision_samba3sam.ldif"), 'r').read())
-
- ldb = Ldb()
- ldb.connect(ldburl)
-
- self.test_s3sam_search(ldb)
- self.test_s3sam_modify(ldb, samba3)
-
- os.unlink(ldbfile)
- os.unlink(samba3.file)
- os.unlink(templates.file)
- os.unlink(samba4.file)
-
- ldb = Ldb()
- ldb.connect(ldburl)
- samba3.db = Ldb()
- samba3.db.connect(samba3.url)
- templates.db = Ldb()
- templates.db.connect(templates.url)
- samba4.db = Ldb()
- samba4.db.connect(samba4.url)
-
- self.setup_data(templates, open(os.path.join(datadir, "provision_samba3sam_templates.ldif"), 'r').read())
- self.setup_modules(ldb, samba3, samba4, open(os.path.join(datadir, "provision_samba3sam.ldif"), 'r').read())
-
- ldb = Ldb()
- ldb.connect(ldburl)
-
- test_map_search(ldb, samba3, samba4)
- test_map_modify(ldb, samba3, samba4)
-
git.samba.org / kai / samba.git / blobdiff