s4:dsdb Add default modules list to samba3sam

[ira/wip.git] / source4 / dsdb / samdb / ldb_modules / tests / samba3sam.py

diff --git a/source4/dsdb/samdb/ldb_modules/tests/samba3sam.py b/source4/dsdb/samdb/ldb_modules/tests/samba3sam.py
index 8ea566c7b3599d554f73b54dfb2e7fdd9cf9528e..2478043eb46126bcfc5dc10445277ba8d8017cd4 100644 (file)
--- a/source4/dsdb/samdb/ldb_modules/tests/samba3sam.py
+++ b/source4/dsdb/samdb/ldb_modules/tests/samba3sam.py
@@ -26,7 +26,9 @@ import os
 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.security
+import samba.ndr
 
 datadir = os.path.join(os.path.dirname(__file__), 
                        "../../../../../testdata/samba3")
@@ -47,12 +49,13 @@ class MapBaseTestCase(TestCaseInTempDir):
                  "@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"})
+                 "@LIST": "rootdse,paged_results,server_sort,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"]})
+            "partition": ["%s" % (s4.basedn_casefold), 
+                          "%s" % (s3.basedn_casefold)],
+            "replicateEntries": ["@ATTRIBUTES", "@INDEXLIST"],
+            "modules": "*:"})
 
     def setUp(self):
         super(MapBaseTestCase, self).setUp()
@@ -71,12 +74,13 @@ class MapBaseTestCase(TestCaseInTempDir):
         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
+            def __init__(self, basedn, dn):
+                self.db = Ldb(lp=cmdline_loadparm)
                 self.basedn = basedn
+                self.basedn_casefold = ldb.Dn(self.db, basedn).get_casefold()
                 self.substvars = {"BASEDN": self.basedn}
-                self.db = Ldb()
+                self.file = os.path.join(tempdir, "%s.ldb" % self.basedn_casefold)
+                self.url = "tdb://" + self.file
                 self._dn = dn
 
             def dn(self, rdn):
@@ -97,34 +101,36 @@ class MapBaseTestCase(TestCaseInTempDir):
             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.samba4 = Target("dc=vernstok,dc=nl", make_s4dn)
+        self.samba3 = Target("cn=Samba3Sam", make_dn)
 
         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.security.dom_sid,
+                                        str(ndr_sid[0]))
+        sid_obj2 = samba.dcerpc.security.dom_sid(text)
+        self.assertEquals(sid_obj1, sid_obj2)
+
 
 class Samba3SamTestCase(MapBaseTestCase):
 
     def setUp(self):
         super(Samba3SamTestCase, self).setUp()
-        ldb = Ldb(self.ldburl)
+        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)
+        self.ldb = Ldb(self.ldburl, lp=cmdline_loadparm)
 
     def test_search_non_mapped(self):
         """Looking up by non-mapped attribute"""
@@ -136,7 +142,7 @@ class Samba3SamTestCase(MapBaseTestCase):
         """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")
+        self.assertEquals(str(msg[0]["name"]), "Backup Operators")
 
     def test_old_name_of_renamed(self):
         """Looking up by old name of renamed attribute"""
@@ -150,10 +156,8 @@ class Samba3SamTestCase(MapBaseTestCase):
         self.assertEquals(str(msg[0].dn), 
                           "cn=Replicator,ou=Groups,dc=vernstok,dc=nl")
         self.assertTrue("objectSid" in msg[0]) 
-        # FIXME: NDR unpack msg[0]["objectSid"] before comparing:
-        # self.assertEquals(msg[0]["objectSid"], 
-        #                   "S-1-5-21-4231626423-2410014848-2360679739-552")
-        # Check mapping of objectClass
+        self.assertSidEquals("S-1-5-21-4231626423-2410014848-2360679739-552",
+                             msg[0]["objectSid"])
         oc = set(msg[0]["objectClass"])
         self.assertEquals(oc, set(["group"]))
 
@@ -184,9 +188,9 @@ class Samba3SamTestCase(MapBaseTestCase):
                 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")
+        self.assertEquals(str(msg[0]["showInAdvancedViewOnly"]), "TRUE")
+        self.assertEquals(str(msg[0]["foo"]), "bar")
+        self.assertEquals(str(msg[0]["blah"]), "Blie")
 
         # Adding record that will be mapped
         self.ldb.add({"dn": "cn=Niemand,cn=Users,dc=vernstok,dc=nl",
@@ -199,32 +203,32 @@ class Samba3SamTestCase(MapBaseTestCase):
         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")
+        self.assertEquals(str(msg[0]["cn"]), "Niemand")
+        self.assertEquals(str(msg[0]["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")
+        self.assertEquals(str(msg[0]["cn"]), "Niemand")
+        self.assertEquals(str(msg[0]["unixName"]), "bin")
+        self.assertEquals(str(msg[0]["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 %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")
-        self.assertEquals(msg[0]["sambaUnicodePwd"], "geheim")
+        self.assertEquals(str(msg[0]["cn"]), "Niemand")
+        self.assertEquals(str(msg[0]["unixName"]), "bin")
+        self.assertEquals(str(msg[0]["sambaUnicodePwd"]), "geheim")
 
         # Checking for data in destination database
         msg = self.samba3.db.search(expression="(cn=Niemand)")
         self.assertTrue(len(msg) >= 1)
-        self.assertEquals(msg[0]["sambaSID"], 
+        self.assertEquals(str(msg[0]["sambaSID"]), 
                 "S-1-5-21-4231626423-2410014848-2360679739-2001")
-        self.assertEquals(msg[0]["displayName"], "Niemand")
+        self.assertEquals(str(msg[0]["displayName"]), "Niemand")
 
         # Adding attribute...
         self.ldb.modify_ldif("""
@@ -237,8 +241,8 @@ description: Blah
         # 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")
+        self.assertEquals(str(msg[0]["cn"]), "Niemand")
+        self.assertEquals(str(msg[0]["description"]), "Blah")
 
         # Modifying attribute...
         self.ldb.modify_ldif("""
@@ -251,7 +255,7 @@ description: Blie
         # Checking whether changes are still there...
         msg = self.ldb.search(expression="(cn=Niemand)")
         self.assertTrue(len(msg) >= 1)
-        self.assertEquals(msg[0]["description"], "Blie")
+        self.assertEquals(str(msg[0]["description"]), "Blie")
 
         # Deleting attribute...
         self.ldb.modify_ldif("""
@@ -287,18 +291,15 @@ class MapTestCase(MapBaseTestCase):
 
     def setUp(self):
         super(MapTestCase, self).setUp()
-        ldb = Ldb(self.ldburl)
-        self.templates.setup_data("provision_samba3sam_templates.ldif")
+        ldb = Ldb(self.ldburl, lp=cmdline_loadparm)
         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)
+        self.ldb = Ldb(self.ldburl, lp=cmdline_loadparm)
 
     def test_map_search(self):
         """Running search tests on mapped data."""
-        ldif = """
-"""
         self.samba3.db.add({
             "dn": "sambaDomainName=TESTS," + self.samba3.basedn,
             "objectclass": ["sambaDomain", "top"],
@@ -308,18 +309,26 @@ class MapTestCase(MapBaseTestCase):
             })
 
         # Add a set of split records
-        self.ldb.add({
-            "dn": self.samba4.dn("cn=X"),
-            "objectClass": "user",
-            "cn": "X",
-            "codePage": "x",
-            "revision": "x",
-            "dnsHostName": "x",
-            "nextRid": "y",
-            "lastLogon": "x",
-            "description": "x",
-            "objectSid": "S-1-5-21-4231626423-2410014848-2360679739-552",
-            "primaryGroupID": "1-5-21-4231626423-2410014848-2360679739-512"})
+        self.ldb.add_ldif("""
+dn: """+ self.samba4.dn("cn=Domain Users") + """
+objectClass: group
+cn: Domain Users
+objectSid: S-1-5-21-4231626423-2410014848-2360679739-513
+""")
+
+        # Add a set of split records
+        self.ldb.add_ldif("""
+dn: """+ self.samba4.dn("cn=X") + """
+objectClass: user
+cn: X
+codePage: x
+revision: x
+dnsHostName: x
+nextRid: y
+lastLogon: x
+description: x
+objectSid: S-1-5-21-4231626423-2410014848-2360679739-552
+""")
 
         self.ldb.add({
             "dn": self.samba4.dn("cn=Y"),
@@ -383,7 +392,7 @@ class MapTestCase(MapBaseTestCase):
         self.assertEquals(len(res), 1)
         self.assertEquals(str(res[0].dn), dn)
         self.assertTrue(not "dnsHostName" in res[0])
-        self.assertEquals(res[0]["lastLogon"], "x")
+        self.assertEquals(str(res[0]["lastLogon"]), "x")
 
         # Search remote record by remote DN
         dn = self.samba3.dn("cn=A")
@@ -393,7 +402,7 @@ class MapTestCase(MapBaseTestCase):
         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")
+        self.assertEquals(str(res[0]["sambaLogonTime"]), "x")
 
         # Search split record by local DN
         dn = self.samba4.dn("cn=X")
@@ -401,8 +410,8 @@ class MapTestCase(MapBaseTestCase):
                 attrs=["dnsHostName", "lastLogon"])
         self.assertEquals(len(res), 1)
         self.assertEquals(str(res[0].dn), dn)
-        self.assertEquals(res[0]["dnsHostName"], "x")
-        self.assertEquals(res[0]["lastLogon"], "x")
+        self.assertEquals(str(res[0]["dnsHostName"]), "x")
+        self.assertEquals(str(res[0]["lastLogon"]), "x")
 
         # Search split record by remote DN
         dn = self.samba3.dn("cn=X")
@@ -412,7 +421,7 @@ class MapTestCase(MapBaseTestCase):
         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")
+        self.assertEquals(str(res[0]["sambaLogonTime"]), "x")
 
         # Testing search by attribute
 
@@ -421,22 +430,22 @@ class MapTestCase(MapBaseTestCase):
                 attrs=["dnsHostName", "lastLogon"])
         self.assertEquals(len(res), 2)
         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[0]["dnsHostName"]), "y")
+        self.assertEquals(str(res[0]["lastLogon"]), "y")
         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[1]["dnsHostName"]), "x")
+        self.assertEquals(str(res[1]["lastLogon"]), "x")
 
         # Search by kept attribute
         res = self.ldb.search(expression="(description=y)", 
                 scope=SCOPE_DEFAULT, attrs=["dnsHostName", "lastLogon"])
         self.assertEquals(len(res), 2)
         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[0]["dnsHostName"]), "z")
+        self.assertEquals(str(res[0]["lastLogon"]), "z")
         self.assertEquals(str(res[1].dn), self.samba4.dn("cn=C"))
         self.assertTrue(not "dnsHostName" in res[1])
-        self.assertEquals(res[1]["lastLogon"], "z")
+        self.assertEquals(str(res[1]["lastLogon"]), "z")
 
         # Search by renamed attribute
         res = self.ldb.search(expression="(badPwdCount=x)", scope=SCOPE_DEFAULT,
@@ -444,29 +453,30 @@ class MapTestCase(MapBaseTestCase):
         self.assertEquals(len(res), 2)
         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[0]["lastLogon"]), "y")
         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[1]["lastLogon"]), "x")
 
         # Search by converted attribute
         # TODO:
         #   Using the SID directly in the parse tree leads to conversion
         #   errors, letting the search fail with no results.
         #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,
-                              attrs=["dnsHostName", "lastLogon", "objectSid"])
-        self.assertEquals(len(res), 3)
+        res = self.ldb.search(expression="(objectSid=*)", base=None, scope=SCOPE_DEFAULT, attrs=["dnsHostName", "lastLogon", "objectSid"])
+        self.assertEquals(len(res), 4)
         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[0]["dnsHostName"]), "x")
+        self.assertEquals(str(res[0]["lastLogon"]), "x")
+        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.assertEquals(str(res[1]["lastLogon"]), "x")
+        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
@@ -476,14 +486,11 @@ class MapTestCase(MapBaseTestCase):
         self.assertEquals(len(res), 1)
         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")
-
-        # TODO: There should actually be two results, A and X.  The
-        # primaryGroupID of X seems to get corrupted somewhere, and the
-        # objectSid isn't available during the generation of remote (!) data,
-        # which can be observed with the following search.  Also note that Xs
-        # objectSid seems to be fine in the previous search for objectSid... */
+        self.assertEquals(str(res[0]["lastLogon"]), "x")
+        self.assertEquals(str(res[0]["primaryGroupID"]), "512")
+
+        # Note that Xs "objectSid" seems to be fine in the previous search for
+        # "objectSid"...
         #res = ldb.search(expression="(primaryGroupID=*)", NULL, ldb. SCOPE_DEFAULT, attrs)
         #print len(res) + " results found"
         #for i in range(len(res)):
@@ -503,13 +510,13 @@ class MapTestCase(MapBaseTestCase):
         res = self.ldb.search(expression="(objectClass=user)", attrs=attrs)
         self.assertEquals(len(res), 2)
         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]["objectClass"][0], "user")
+        self.assertEquals(str(res[0]["dnsHostName"]), "x")
+        self.assertEquals(str(res[0]["lastLogon"]), "x")
+        self.assertEquals(str(res[0]["objectClass"][0]), "user")
         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]["objectClass"][0], "user")
+        self.assertEquals(str(res[1]["lastLogon"]), "x")
+        self.assertEquals(str(res[1]["objectClass"][0]), "user")
 
         # Prove that the objectClass is actually used for the search
         res = self.ldb.search(expression="(|(objectClass=user)(badPwdCount=x))",
@@ -517,15 +524,15 @@ class MapTestCase(MapBaseTestCase):
         self.assertEquals(len(res), 3)
         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(set(res[0]["objectClass"]), set(["user"]))
+        self.assertEquals(str(res[0]["lastLogon"]), "y")
+        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.assertEquals(res[1]["objectClass"][0], "user")
+        self.assertEquals(str(res[1]["dnsHostName"]), "x")
+        self.assertEquals(str(res[1]["lastLogon"]), "x")
+        self.assertEquals(str(res[1]["objectClass"][0]), "user")
         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[2]["lastLogon"]), "x")
         self.assertEquals(res[2]["objectClass"][0], "user")
 
         # Testing search by parse tree
@@ -535,33 +542,33 @@ class MapTestCase(MapBaseTestCase):
                               attrs=["dnsHostName", "lastLogon"])
         self.assertEquals(len(res), 2)
         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[0]["dnsHostName"]), "y")
+        self.assertEquals(str(res[0]["lastLogon"]), "y")
         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[1]["dnsHostName"]), "x")
+        self.assertEquals(str(res[1]["lastLogon"]), "x")
 
         # Search by conjunction of remote attributes
         res = self.ldb.search(expression="(&(lastLogon=x)(description=x))", 
                               attrs=["dnsHostName", "lastLogon"])
         self.assertEquals(len(res), 2)
         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[0]["dnsHostName"]), "x")
+        self.assertEquals(str(res[0]["lastLogon"]), "x")
         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[1]["lastLogon"]), "x")
         
         # Search by conjunction of local and remote attribute 
         res = self.ldb.search(expression="(&(codePage=x)(description=x))", 
                               attrs=["dnsHostName", "lastLogon"])
         self.assertEquals(len(res), 2)
         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[0]["dnsHostName"]), "y")
+        self.assertEquals(str(res[0]["lastLogon"]), "y")
         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[1]["dnsHostName"]), "x")
+        self.assertEquals(str(res[1]["lastLogon"]), "x")
 
         # Search by conjunction of local and remote attribute w/o match
         attrs = ["dnsHostName", "lastLogon"]
@@ -577,39 +584,39 @@ class MapTestCase(MapBaseTestCase):
                               attrs=["dnsHostName", "lastLogon"])
         self.assertEquals(len(res), 2)
         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[0]["dnsHostName"]), "y")
+        self.assertEquals(str(res[0]["lastLogon"]), "y")
         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[1]["dnsHostName"]), "x")
+        self.assertEquals(str(res[1]["lastLogon"]), "x")
 
         # Search by disjunction of remote attributes
         res = self.ldb.search(expression="(|(badPwdCount=x)(lastLogon=x))", 
                               attrs=["dnsHostName", "lastLogon"])
         self.assertEquals(len(res), 3)
         self.assertEquals(str(res[0].dn), self.samba4.dn("cn=B"))
-        self.assertTrue("dnsHostName" in res[0])
-        self.assertEquals(res[0]["lastLogon"], "y")
+        self.assertFalse("dnsHostName" in res[0])
+        self.assertEquals(str(res[0]["lastLogon"]), "y")
         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[1]["dnsHostName"]), "x")
+        self.assertEquals(str(res[1]["lastLogon"]), "x")
         self.assertEquals(str(res[2].dn), self.samba4.dn("cn=A"))
-        self.assertTrue("dnsHostName" in res[2])
-        self.assertEquals(res[2]["lastLogon"], "x")
+        self.assertFalse("dnsHostName" in res[2])
+        self.assertEquals(str(res[2]["lastLogon"]), "x")
 
         # Search by disjunction of local and remote attribute
         res = self.ldb.search(expression="(|(revision=x)(lastLogon=y))", 
                               attrs=["dnsHostName", "lastLogon"])
         self.assertEquals(len(res), 3)
         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[0]["dnsHostName"]), "y")
+        self.assertEquals(str(res[0]["lastLogon"]), "y")
         self.assertEquals(str(res[1].dn), self.samba4.dn("cn=B"))
-        self.assertTrue("dnsHostName" in res[1])
-        self.assertEquals(res[1]["lastLogon"], "y")
+        self.assertFalse("dnsHostName" in res[1])
+        self.assertEquals(str(res[1]["lastLogon"]), "y")
         self.assertEquals(str(res[2].dn), self.samba4.dn("cn=X"))
-        self.assertEquals(res[2]["dnsHostName"], "x")
-        self.assertEquals(res[2]["lastLogon"], "x")
+        self.assertEquals(str(res[2]["dnsHostName"]), "x")
+        self.assertEquals(str(res[2]["lastLogon"]), "x")
 
         # Search by disjunction of local and remote attribute w/o match
         res = self.ldb.search(expression="(|(codePage=y)(nextRid=z))", 
@@ -619,144 +626,144 @@ class MapTestCase(MapBaseTestCase):
         # Search by negated local attribute
         res = self.ldb.search(expression="(!(revision=x))", 
                               attrs=["dnsHostName", "lastLogon"])
-        self.assertEquals(len(res), 5)
+        self.assertEquals(len(res), 6)
         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[0]["lastLogon"]), "y")
         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[1]["lastLogon"]), "x")
         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[2]["dnsHostName"]), "z")
+        self.assertEquals(str(res[2]["lastLogon"]), "z")
         self.assertEquals(str(res[3].dn), self.samba4.dn("cn=C"))
         self.assertTrue(not "dnsHostName" in res[3])
-        self.assertEquals(res[3]["lastLogon"], "z")
+        self.assertEquals(str(res[3]["lastLogon"]), "z")
 
         # Search by negated remote attribute
         res = self.ldb.search(expression="(!(description=x))", 
                               attrs=["dnsHostName", "lastLogon"])
-        self.assertEquals(len(res), 3)
+        self.assertEquals(len(res), 4)
         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[0]["dnsHostName"]), "z")
+        self.assertEquals(str(res[0]["lastLogon"]), "z")
         self.assertEquals(str(res[1].dn), self.samba4.dn("cn=C"))
         self.assertTrue(not "dnsHostName" in res[1])
-        self.assertEquals(res[1]["lastLogon"], "z")
+        self.assertEquals(str(res[1]["lastLogon"]), "z")
 
         # Search by negated conjunction of local attributes
         res = self.ldb.search(expression="(!(&(codePage=x)(revision=x)))", 
                               attrs=["dnsHostName", "lastLogon"])
-        self.assertEquals(len(res), 5)
+        self.assertEquals(len(res), 6)
         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[0]["lastLogon"]), "y")
         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[1]["lastLogon"]), "x")
         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[2]["dnsHostName"]), "z")
+        self.assertEquals(str(res[2]["lastLogon"]), "z")
         self.assertEquals(str(res[3].dn), self.samba4.dn("cn=C"))
         self.assertTrue(not "dnsHostName" in res[3])
-        self.assertEquals(res[3]["lastLogon"], "z")
+        self.assertEquals(str(res[3]["lastLogon"]), "z")
 
         # Search by negated conjunction of remote attributes
         res = self.ldb.search(expression="(!(&(lastLogon=x)(description=x)))", 
                               attrs=["dnsHostName", "lastLogon"])
-        self.assertEquals(len(res), 5)
+        self.assertEquals(len(res), 6)
         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[0]["dnsHostName"]), "y")
+        self.assertEquals(str(res[0]["lastLogon"]), "y")
         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[1]["lastLogon"]), "y")
         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[2]["dnsHostName"]), "z")
+        self.assertEquals(str(res[2]["lastLogon"]), "z")
         self.assertEquals(str(res[3].dn), self.samba4.dn("cn=C"))
         self.assertTrue(not "dnsHostName" in res[3])
-        self.assertEquals(res[3]["lastLogon"], "z")
+        self.assertEquals(str(res[3]["lastLogon"]), "z")
 
         # Search by negated conjunction of local and remote attribute
         res = self.ldb.search(expression="(!(&(codePage=x)(description=x)))", 
                               attrs=["dnsHostName", "lastLogon"])
-        self.assertEquals(len(res), 5)
+        self.assertEquals(len(res), 6)
         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[0]["lastLogon"]), "y")
         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[1]["lastLogon"]), "x")
         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[2]["dnsHostName"]), "z")
+        self.assertEquals(str(res[2]["lastLogon"]), "z")
         self.assertEquals(str(res[3].dn), self.samba4.dn("cn=C"))
         self.assertTrue(not "dnsHostName" in res[3])
-        self.assertEquals(res[3]["lastLogon"], "z")
+        self.assertEquals(str(res[3]["lastLogon"]), "z")
 
         # Search by negated disjunction of local attributes
         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[0]["lastLogon"]), "y")
         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[1]["lastLogon"]), "x")
         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[2]["dnsHostName"]), "z")
+        self.assertEquals(str(res[2]["lastLogon"]), "z")
         self.assertEquals(str(res[3].dn), self.samba4.dn("cn=C"))
         self.assertTrue(not "dnsHostName" in res[3])
-        self.assertEquals(res[3]["lastLogon"], "z")
+        self.assertEquals(str(res[3]["lastLogon"]), "z")
 
         # Search by negated disjunction of remote attributes
         res = self.ldb.search(expression="(!(|(badPwdCount=x)(lastLogon=x)))", 
                               attrs=["dnsHostName", "lastLogon"])
-        self.assertEquals(len(res), 4)
+        self.assertEquals(len(res), 5)
         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[0]["dnsHostName"]), "y")
+        self.assertEquals(str(res[0]["lastLogon"]), "y")
         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[1]["dnsHostName"]), "z")
+        self.assertEquals(str(res[1]["lastLogon"]), "z")
         self.assertEquals(str(res[2].dn), self.samba4.dn("cn=C"))
         self.assertTrue(not "dnsHostName" in res[2])
-        self.assertEquals(res[2]["lastLogon"], "z")
+        self.assertEquals(str(res[2]["lastLogon"]), "z")
 
         # Search by negated disjunction of local and remote attribute
         res = self.ldb.search(expression="(!(|(revision=x)(lastLogon=y)))", 
                               attrs=["dnsHostName", "lastLogon"])
-        self.assertEquals(len(res), 4)
+        self.assertEquals(len(res), 5)
         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[0]["lastLogon"]), "x")
         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[1]["dnsHostName"]), "z")
+        self.assertEquals(str(res[1]["lastLogon"]), "z")
         self.assertEquals(str(res[2].dn), self.samba4.dn("cn=C"))
         self.assertTrue(not "dnsHostName" in res[2])
-        self.assertEquals(res[2]["lastLogon"], "z")
+        self.assertEquals(str(res[2]["lastLogon"]), "z")
 
         # 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(len(res), 7)
         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[0]["lastLogon"]), "y")
         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[1]["dnsHostName"]), "x")
+        self.assertEquals(str(res[1]["lastLogon"]), "x")
         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[2]["lastLogon"]), "x")
         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[3]["dnsHostName"]), "z")
+        self.assertEquals(str(res[3]["lastLogon"]), "z")
         self.assertEquals(str(res[4].dn), self.samba4.dn("cn=C"))
         self.assertTrue(not "dnsHostName" in res[4])
-        self.assertEquals(res[4]["lastLogon"], "z")
+        self.assertEquals(str(res[4]["lastLogon"]), "z")
 
         # Clean up
         dns = [self.samba4.dn("cn=%s" % n) for n in ["A","B","C","X","Y","Z"]]
@@ -777,9 +784,9 @@ class MapTestCase(MapBaseTestCase):
         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")
+        self.assertEquals(str(res[0]["foo"]), "bar")
+        self.assertEquals(str(res[0]["revision"]), "1")
+        self.assertEquals(str(res[0]["description"]), "test")
         # Check it's not in the local db
         res = self.samba4.db.search(expression="(cn=test)", 
                                     scope=SCOPE_DEFAULT, attrs=attrs)
@@ -802,9 +809,9 @@ description: foo
         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")
-        self.assertEquals(res[0]["revision"], "1")
-        self.assertEquals(res[0]["description"], "foo")
+        self.assertEquals(str(res[0]["foo"]), "baz")
+        self.assertEquals(str(res[0]["revision"]), "1")
+        self.assertEquals(str(res[0]["description"]), "foo")
 
         # Rename local record
         dn2 = "cn=toast,dc=idealx,dc=org"
@@ -813,9 +820,9 @@ description: foo
         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]["revision"], "1")
-        self.assertEquals(res[0]["description"], "foo")
+        self.assertEquals(str(res[0]["foo"]), "baz")
+        self.assertEquals(str(res[0]["revision"]), "1")
+        self.assertEquals(str(res[0]["description"]), "foo")
 
         # Delete local record
         self.ldb.delete(dn2)
@@ -838,17 +845,17 @@ description: foo
                 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]["sambaBadPasswordCount"], "3")
-        self.assertEquals(res[0]["sambaNextRid"], "1001")
+        self.assertEquals(str(res[0]["description"]), "foo")
+        self.assertEquals(str(res[0]["sambaBadPasswordCount"]), "3")
+        self.assertEquals(str(res[0]["sambaNextRid"]), "1001")
         # Check in mapped db
         attrs = ["description", "badPwdCount", "nextRid"]
         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")
+        self.assertEquals(str(res[0]["description"]), "foo")
+        self.assertEquals(str(res[0]["badPwdCount"]), "3")
+        self.assertEquals(str(res[0]["nextRid"]), "1001")
         # Check in local db
         res = self.samba4.db.search(dn, scope=SCOPE_BASE, attrs=attrs)
         self.assertEquals(len(res), 0)
@@ -867,17 +874,17 @@ badPwdCount: 4
                 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")
+        self.assertEquals(str(res[0]["description"]), "test")
+        self.assertEquals(str(res[0]["badPwdCount"]), "4")
+        self.assertEquals(str(res[0]["nextRid"]), "1001")
         # Check in remote db
         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]["sambaBadPasswordCount"], "4")
-        self.assertEquals(res[0]["sambaNextRid"], "1001")
+        self.assertEquals(str(res[0]["description"]), "test")
+        self.assertEquals(str(res[0]["sambaBadPasswordCount"]), "4")
+        self.assertEquals(str(res[0]["sambaNextRid"]), "1001")
 
         # Rename remote record
         dn2 = self.samba4.dn("cn=toast")
@@ -888,18 +895,18 @@ badPwdCount: 4
                 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")
+        self.assertEquals(str(res[0]["description"]), "test")
+        self.assertEquals(str(res[0]["badPwdCount"]), "4")
+        self.assertEquals(str(res[0]["nextRid"]), "1001")
         # Check in remote db 
         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]["sambaBadPasswordCount"], "4")
-        self.assertEquals(res[0]["sambaNextRid"], "1001")
+        self.assertEquals(str(res[0]["description"]), "test")
+        self.assertEquals(str(res[0]["sambaBadPasswordCount"]), "4")
+        self.assertEquals(str(res[0]["sambaNextRid"]), "1001")
 
         # Delete remote record
         self.ldb.delete(dn)
@@ -936,20 +943,20 @@ description: test
         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")
+        self.assertEquals(str(res[0]["description"]), "test")
+        self.assertEquals(str(res[0]["revision"]), "1")
         # Check in remote db
         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(str(res[0]["description"]), "test")
         self.assertTrue(not "revision" in res[0])
         # Check in local db
         res = self.samba4.db.search(dn, scope=SCOPE_BASE, attrs=attrs)
         self.assertEquals(len(res), 1)
         self.assertEquals(str(res[0].dn), dn)
         self.assertTrue(not "description" in res[0])
-        self.assertEquals(res[0]["revision"], "1")
+        self.assertEquals(str(res[0]["revision"]), "1")
 
         # Delete (newly) split record
         self.ldb.delete(dn)
@@ -971,10 +978,10 @@ description: test
         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]["badPwdCount"], "3")
-        self.assertEquals(res[0]["nextRid"], "1001")
-        self.assertEquals(res[0]["revision"], "1")
+        self.assertEquals(str(res[0]["description"]), "foo")
+        self.assertEquals(str(res[0]["badPwdCount"]), "3")
+        self.assertEquals(str(res[0]["nextRid"]), "1001")
+        self.assertEquals(str(res[0]["revision"]), "1")
         # Check in local db
         res = self.samba4.db.search(dn, scope=SCOPE_BASE, attrs=attrs)
         self.assertEquals(len(res), 1)
@@ -982,16 +989,16 @@ description: test
         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")
+        self.assertEquals(str(res[0]["revision"]), "1")
         # Check in remote db
         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(str(res[0]["description"]), "foo")
+        self.assertEquals(str(res[0]["sambaBadPasswordCount"]), "3")
+        self.assertEquals(str(res[0]["sambaNextRid"]), "1001")
         self.assertTrue(not "revision" in res[0])
 
         # Modify of split record
@@ -1010,10 +1017,10 @@ revision: 2
         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]["badPwdCount"], "4")
-        self.assertEquals(res[0]["nextRid"], "1001")
-        self.assertEquals(res[0]["revision"], "2")
+        self.assertEquals(str(res[0]["description"]), "test")
+        self.assertEquals(str(res[0]["badPwdCount"]), "4")
+        self.assertEquals(str(res[0]["nextRid"]), "1001")
+        self.assertEquals(str(res[0]["revision"]), "2")
         # Check in local db
         res = self.samba4.db.search(dn, scope=SCOPE_BASE, attrs=attrs)
         self.assertEquals(len(res), 1)
@@ -1021,16 +1028,16 @@ revision: 2
         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")
+        self.assertEquals(str(res[0]["revision"]), "2")
         # Check in remote db
         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(str(res[0]["description"]), "test")
+        self.assertEquals(str(res[0]["sambaBadPasswordCount"]), "4")
+        self.assertEquals(str(res[0]["sambaNextRid"]), "1001")
         self.assertTrue(not "revision" in res[0])
 
         # Rename split record
@@ -1042,10 +1049,10 @@ revision: 2
         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]["badPwdCount"], "4")
-        self.assertEquals(res[0]["nextRid"], "1001")
-        self.assertEquals(res[0]["revision"], "2")
+        self.assertEquals(str(res[0]["description"]), "test")
+        self.assertEquals(str(res[0]["badPwdCount"]), "4")
+        self.assertEquals(str(res[0]["nextRid"]), "1001")
+        self.assertEquals(str(res[0]["revision"]), "2")
         # Check in local db
         res = self.samba4.db.search(dn, scope=SCOPE_BASE, attrs=attrs)
         self.assertEquals(len(res), 1)
@@ -1053,7 +1060,7 @@ revision: 2
         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")
+        self.assertEquals(str(res[0]["revision"]), "2")
         # Check in remote db
         dn2 = self.samba3.dn("cn=toast")
         res = self.samba3.db.search(dn2, scope=SCOPE_BASE, 
@@ -1061,9 +1068,9 @@ revision: 2
                  "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(str(res[0]["description"]), "test")
+        self.assertEquals(str(res[0]["sambaBadPasswordCount"]), "4")
+        self.assertEquals(str(res[0]["sambaNextRid"]), "1001")
         self.assertTrue(not "revision" in res[0])
 
         # Delete split record