ldap/python: Fix some more calls.

diff --git a/source/lib/ldb/tests/python/ldap.py b/source/lib/ldb/tests/python/ldap.py
index 3f70ef9b43ca9b511bf73a1c020c3d0f47142837..1e7ed48d0719be06abdc285aa203c4b334c714fe 100755 (executable)
--- a/source/lib/ldb/tests/python/ldap.py
+++ b/source/lib/ldb/tests/python/ldap.py
@@ -11,6 +11,7 @@ sys.path.append("scripting/python")
 import samba.getopt as options
 
 from auth import system_session
+from ldb import SCOPE_SUBTREE, SCOPE_ONELEVEL, SCOPE_BASE
 from samba import Ldb
 import param
 
@@ -183,34 +184,34 @@ servicePrincipalName: host/ldaptest2computer29
         assertEquals(res[0]["servicePrincipalName;range=0-*"].length, 30)
 
         attrs = ["servicePrincipalName;range=0-19"]
-        res = ldb.search("(cn=ldaptest2computer))", base_dn, ldb.SCOPE_SUBTREE, attrs)
+        res = ldb.search(base_dn, "(cn=ldaptest2computer))", SCOPE_SUBTREE, attrs)
         assert len(res) == 1, "Could not find (cn=ldaptest2computer)"
 #        print res[0]["servicePrincipalName;range=0-19"].length
         assertEquals(res[0]["servicePrincipalName;range=0-19"].length, 20)
 
         attrs = ["servicePrincipalName;range=0-30"]
-        res = ldb.search("(cn=ldaptest2computer))", base_dn, ldb.SCOPE_SUBTREE, attrs)
+        res = ldb.search(base_dn, "(cn=ldaptest2computer))", SCOPE_SUBTREE, attrs)
         assert len(res) == 1, "Could not find (cn=ldaptest2computer)"
         assertEquals(res[0]["servicePrincipalName;range=0-*"].length, 30)
 
         attrs = ["servicePrincipalName;range=0-40"]
-        res = ldb.search("(cn=ldaptest2computer))", base_dn, ldb.SCOPE_SUBTREE, attrs)
+        res = ldb.search(base_dn, "(cn=ldaptest2computer))", SCOPE_SUBTREE, attrs)
         assert len(res) == 1, "Could not find (cn=ldaptest2computer)"
         assertEquals(res[0]["servicePrincipalName;range=0-*"].length, 30)
 
         attrs = ["servicePrincipalName;range=30-40"]
-        res = ldb.search("(cn=ldaptest2computer))", base_dn, ldb.SCOPE_SUBTREE, attrs)
+        res = ldb.search(base_dn, "(cn=ldaptest2computer))", SCOPE_SUBTREE, attrs)
         assert len(res) == 1, "Could not find (cn=ldaptest2computer)"
         assertEquals(res[0]["servicePrincipalName;range=30-*"].length, 0)
 
         attrs = ["servicePrincipalName;range=10-40"]
-        res = ldb.search("(cn=ldaptest2computer))", base_dn, ldb.SCOPE_SUBTREE, attrs)
+        res = ldb.search(base_dn, "(cn=ldaptest2computer))", SCOPE_SUBTREE, attrs)
         assert len(res) == 1, "Could not find (cn=ldaptest2computer)"
         assertEquals(res[0]["servicePrincipalName;range=10-*"].length, 20)
 #        pos_11 = res[0]["servicePrincipalName;range=10-*"][18]
 
         attrs = ["servicePrincipalName;range=11-40"]
-        res = ldb.search("(cn=ldaptest2computer))", base_dn, ldb.SCOPE_SUBTREE, attrs)
+        res = ldb.search(base_dn, "(cn=ldaptest2computer))", SCOPE_SUBTREE, attrs)
         assert len(res) == 1, "Could not find (cn=ldaptest2computer)"
         assertEquals(res[0]["servicePrincipalName;range=11-*"].length, 19)
 #        print res[0]["servicePrincipalName;range=11-*"][18]
@@ -218,13 +219,13 @@ servicePrincipalName: host/ldaptest2computer29
 #        assertEquals((res[0]["servicePrincipalName;range=11-*"][18]), pos_11)
 
         attrs = ["servicePrincipalName;range=11-15"]
-        res = ldb.search("(cn=ldaptest2computer))", base_dn, ldb.SCOPE_SUBTREE, attrs)
+        res = ldb.search(base_dn, "(cn=ldaptest2computer))", SCOPE_SUBTREE, attrs)
         assert len(res) == 1, "Could not find (cn=ldaptest2computer)"
         assertEquals(res[0]["servicePrincipalName;range=11-15"].length, 5)
 #        assertEquals(res[0]["servicePrincipalName;range=11-15"][4], pos_11)
 
         attrs = ["servicePrincipalName"]
-        res = ldb.search("(cn=ldaptest2computer))", base_dn, ldb.SCOPE_SUBTREE, attrs)
+        res = ldb.search(base_dn, "(cn=ldaptest2computer))", SCOPE_SUBTREE, attrs)
         assert len(res) == 1, "Could not find (cn=ldaptest2computer)"
 #        print res[0]["servicePrincipalName"][18]
 #        print pos_11
@@ -249,19 +250,19 @@ servicePrincipalName: host/ldaptest2computer29
 
     print "Testing Ambigious Name Resolution"
 #   Testing ldb.search for (&(anr=ldap testy)(objectClass=user))
-    res = ldb.search("(&(anr=ldap testy)(objectClass=user))")
+    res = ldb.search(expression="(&(anr=ldap testy)(objectClass=user))")
     assert len(res) == 3, "Could not find (&(anr=ldap testy)(objectClass=user))"
 
 #   Testing ldb.search for (&(anr=testy ldap)(objectClass=user))
-    res = ldb.search("(&(anr=testy ldap)(objectClass=user))")
+    res = ldb.search(expression="(&(anr=testy ldap)(objectClass=user))")
     assert len(res) == 2, "Found only %d for (&(anr=testy ldap)(objectClass=user))" % len(res)
 
 #   Testing ldb.search for (&(anr=ldap)(objectClass=user))
-    res = ldb.search("(&(anr=ldap)(objectClass=user))")
+    res = ldb.search(expression="(&(anr=ldap)(objectClass=user))")
     assert len(res) == 4, "Found only %d for (&(anr=ldap)(objectClass=user))" % len(res)
 
 #   Testing ldb.search for (&(anr==ldap)(objectClass=user))
-    res = ldb.search("(&(anr==ldap)(objectClass=user))")
+    res = ldb.search(expression="(&(anr==ldap)(objectClass=user))")
     assert len(res) == 1, "Could not find (&(anr==ldap)(objectClass=user)). Found only %d for (&(anr=ldap)(objectClass=user))" % len(res)
 
     assertEquals(res[0].dn, ("CN=ldaptestuser,CN=Users," + base_dn))
@@ -269,15 +270,15 @@ servicePrincipalName: host/ldaptest2computer29
     assertEquals(res[0].name, "ldaptestuser")
 
 #   Testing ldb.search for (&(anr=testy)(objectClass=user))
-    res = ldb.search("(&(anr=testy)(objectClass=user))")
+    res = ldb.search(expression="(&(anr=testy)(objectClass=user))")
     assert len(res) == 2, "Found only %d for (&(anr=testy)(objectClass=user))" % len(res)
 
 #   Testing ldb.search for (&(anr=ldap testy)(objectClass=user))
-    res = ldb.search("(&(anr=testy ldap)(objectClass=user))")
+    res = ldb.search(expression="(&(anr=testy ldap)(objectClass=user))")
     assert len(res) == 2, "Found only %d for (&(anr=ldap testy)(objectClass=user))" % len(res)
 
 #   Testing ldb.search for (&(anr==ldap testy)(objectClass=user))
-    res = ldb.search("(&(anr==testy ldap)(objectClass=user))")
+    res = ldb.search(expression="(&(anr==testy ldap)(objectClass=user))")
     assert len(res) == 1, "Found only %d for (&(anr==ldap testy)(objectClass=user))" % len(res)
 
     assertEquals(res[0].dn, ("CN=ldaptestuser,CN=Users," + base_dn))
@@ -285,7 +286,7 @@ servicePrincipalName: host/ldaptest2computer29
     assertEquals(res[0].name, "ldaptestuser")
 
 # Testing ldb.search for (&(anr==testy ldap)(objectClass=user))
-    res = ldb.search("(&(anr==testy ldap)(objectClass=user))")
+    res = ldb.search(expression="(&(anr==testy ldap)(objectClass=user))")
     assert len(res) == 1, "Could not find (&(anr==testy ldap)(objectClass=user))"
 
     assertEquals(res[0].dn, ("CN=ldaptestuser,CN=Users," + base_dn))
@@ -293,7 +294,7 @@ servicePrincipalName: host/ldaptest2computer29
     assertEquals(res[0].name, "ldaptestuser")
 
     # Testing ldb.search for (&(anr=testy ldap user)(objectClass=user))
-    res = ldb.search("(&(anr=testy ldap user)(objectClass=user))")
+    res = ldb.search(expression="(&(anr=testy ldap user)(objectClass=user))")
     assert len(res) == 1, "Could not find (&(anr=testy ldap user)(objectClass=user))"
 
     assertEquals(res[0].dn, ("CN=ldaptestuser2,CN=Users," + base_dn))
@@ -301,7 +302,7 @@ servicePrincipalName: host/ldaptest2computer29
     assertEquals(res[0].name, "ldaptestuser2")
 
     # Testing ldb.search for (&(anr==testy ldap user2)(objectClass=user))
-    res = ldb.search("(&(anr==testy ldap user2)(objectClass=user))")
+    res = ldb.search(expression="(&(anr==testy ldap user2)(objectClass=user))")
     assert len(res) == 1, "Could not find (&(anr==testy ldap user2)(objectClass=user))"
 
     assertEquals(res[0].dn, ("CN=ldaptestuser2,CN=Users," + base_dn))
@@ -309,7 +310,7 @@ servicePrincipalName: host/ldaptest2computer29
     assertEquals(res[0].name, "ldaptestuser2")
 
     # Testing ldb.search for (&(anr==ldap user2)(objectClass=user))
-    res = ldb.search("(&(anr==ldap user2)(objectClass=user))")
+    res = ldb.search(expression="(&(anr==ldap user2)(objectClass=user))")
     assert len(res) == 1, "Could not find (&(anr==ldap user2)(objectClass=user))"
 
     assertEquals(res[0].dn, ("CN=ldaptestuser2,CN=Users," + base_dn))
@@ -317,11 +318,11 @@ servicePrincipalName: host/ldaptest2computer29
     assertEquals(res[0].name, "ldaptestuser2")
 
     # Testing ldb.search for (&(anr==not ldap user2)(objectClass=user))
-    res = ldb.search("(&(anr==not ldap user2)(objectClass=user))")
+    res = ldb.search(expression="(&(anr==not ldap user2)(objectClass=user))")
     assert len(res) == 0, "Must not find (&(anr==not ldap user2)(objectClass=user))"
 
     # Testing ldb.search for (&(anr=not ldap user2)(objectClass=user))
-    res = ldb.search("(&(anr=not ldap user2)(objectClass=user))")
+    res = ldb.search(expression="(&(anr=not ldap user2)(objectClass=user))")
     assert len(res) == 0, "Must not find (&(anr=not ldap user2)(objectClass=user))"
 
     print "Testing Group Modifies"
@@ -357,7 +358,7 @@ member: cn=ldaptestuser3,cn=users,""" + base_dn + """
     ok = ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestUSER3,cn=users," + base_dn)
 
     print "Testing ldb.search for (&(cn=ldaptestuser3)(objectClass=user))"
-    res = ldb.search("(&(cn=ldaptestuser3)(objectClass=user))")
+    res = ldb.search(expression="(&(cn=ldaptestuser3)(objectClass=user))")
     assert len(res) == 1, "Could not find (&(cn=ldaptestuser3)(objectClass=user))"
 
     assertEquals(res[0].dn, ("CN=ldaptestUSER3,CN=Users," + base_dn))
@@ -369,7 +370,6 @@ member: cn=ldaptestuser3,cn=users,""" + base_dn + """
 #    res = ldb.search("(dn=CN=ldaptestUSER3,CN=Users," + base_dn + ")")
 #    if (res.error != 0 || len(res) != 1) {
 #        print "Could not find (dn=CN=ldaptestUSER3,CN=Users," + base_dn + ")"
-#        assertEquals(res.error, 0)
 #        assertEquals(len(res), 1)
 #    }
 #    assertEquals(res[0].dn, ("CN=ldaptestUSER3,CN=Users," + base_dn))
@@ -377,7 +377,7 @@ member: cn=ldaptestuser3,cn=users,""" + base_dn + """
 #    assertEquals(res[0].name, "ldaptestUSER3")
 
     print "Testing ldb.search for (distinguishedName=CN=ldaptestUSER3,CN=Users," + base_dn + ")"
-    res = ldb.search("(distinguishedName=CN=ldaptestUSER3,CN=Users," + base_dn + ")")
+    res = ldb.search(expression="(distinguishedName=CN=ldaptestUSER3,CN=Users," + base_dn + ")")
     assert len(res) == 1, "Could not find (dn=CN=ldaptestUSER3,CN=Users," + base_dn + ")"
     assertEquals(res[0].dn, ("CN=ldaptestUSER3,CN=Users," + base_dn))
     assertEquals(res[0].cn, "ldaptestUSER3")
@@ -454,12 +454,12 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """
     ldb.rename("CN=ldaptestcontainer," + base_dn, "CN=ldaptestcontainer2," + base_dn)
 
     print "Testing ldb.search for (&(cn=ldaptestuser4)(objectClass=user))"
-    res = ldb.search("(&(cn=ldaptestuser4)(objectClass=user))")
+    res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))")
     assert len(res) == 1, "Could not find (&(cn=ldaptestuser4)(objectClass=user))"
 
     print "Testing subtree ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + base_dn
     try:
-        res = ldb.search("(&(cn=ldaptestuser4)(objectClass=user))", "cn=ldaptestcontainer," + base_dn, ldb.SCOPE_SUBTREE)
+        res = ldb.search("cn=ldaptestcontainer," + base_dn, expression="(&(cn=ldaptestuser4)(objectClass=user))", scope=SCOPE_SUBTREE)
     except LdbError, (num, _):
         assert num == 32
     else:
@@ -467,21 +467,21 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """
 
     print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + base_dn
     try:
-        res = ldb.search("(&(cn=ldaptestuser4)(objectClass=user))", "cn=ldaptestcontainer," + base_dn, ldb.SCOPE_ONELEVEL)
+        res = ldb.search("cn=ldaptestcontainer," + base_dn, expression="(&(cn=ldaptestuser4)(objectClass=user))", scope=SCOPE_ONELEVEL)
     except LdbError, (num, _):
         assert num == 32
     else:
         assert False
 
     print "Testing ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in renamed container"
-    res = ldb.search("(&(cn=ldaptestuser4)(objectClass=user))", "cn=ldaptestcontainer2," + base_dn, ldb.SCOPE_SUBTREE)
+    res = ldb.search("cn=ldaptestcontainer2," + base_dn, expression="(&(cn=ldaptestuser4)(objectClass=user))", scope=SCOPE_SUBTREE)
     assert len(res) == 1, "Could not find (&(cn=ldaptestuser4)(objectClass=user)) under cn=ldaptestcontainer2," + base_dn
 
     assertEquals(res[0].dn, ("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn))
     assertEquals(strupper(res[0].memberOf[0]), strupper(("CN=ldaptestgroup2,CN=Users," + base_dn)))
 
     print "Testing ldb.search for (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn + ")(objectclass=group)) to check subtree renames and linked attributes"
-    res = ldb.search("(&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn + ")(objectclass=group))", base_dn, ldb.SCOPE_SUBTREE)
+    res = ldb.search(base_dn, "(&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn + ")(objectclass=group))", SCOPE_SUBTREE)
     assert len(res) == 1, "Could not find (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn + ")(objectclass=group)), perhaps linked attributes are not conistant with subtree renames?"
 
     print "Testing ldb.rename (into itself) of cn=ldaptestcontainer2," + base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer2," + base_dn
@@ -509,17 +509,17 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """
         assert False
 
     print "Testing base ldb.search for CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn
-    res = ldb.search("(objectclass=*)", ("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn), ldb.SCOPE_BASE)
+    res = ldb.search(expression="(objectclass=*)", base=("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn), scope=SCOPE_BASE)
     assert len(res) == 1
-    res = ldb.search("(cn=ldaptestuser40)", ("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn), ldb.SCOPE_BASE)
+    res = ldb.search(expression="(cn=ldaptestuser40)", base=("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn), scope=SCOPE_BASE)
     assert len(res) == 0
 
     print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in cn=ldaptestcontainer2," + base_dn
-    res = ldb.search("(&(cn=ldaptestuser4)(objectClass=user))", "cn=ldaptestcontainer2," + base_dn, ldb.SCOPE_ONELEVEL)
+    res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))", base="cn=ldaptestcontainer2," + base_dn, scope=SCOPE_ONELEVEL)
     assert len(res) == 0
 
     print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in cn=ldaptestcontainer2," + base_dn
-    res = ldb.search("(&(cn=ldaptestuser4)(objectClass=user))", "cn=ldaptestcontainer2," + base_dn, ldb.SCOPE_SUBTREE)
+    res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))", base="cn=ldaptestcontainer2," + base_dn, scope=SCOPE_SUBTREE)
     assert len(res) == 0
 
     print "Testing delete of subtree renamed "+("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn)
@@ -801,7 +801,6 @@ member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """
     print "Testing that we can't get at the configuration DN from the main search base"
     attrs = ["cn"]
     res = ldb.search("objectClass=crossRef", base_dn, ldb.SCOPE_SUBTREE, attrs)
-    assertEquals(res.error, 0)
     assert len(res) == 0, "Got configuration DN " + res[0].dn + " which should not be able to be seen from main search base"
     assertEquals(len(res), 0)
 
@@ -809,7 +808,6 @@ member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """
     attrs = ["cn"]
     controls = ["search_options:1:2"]
     res = ldb.search("objectClass=crossRef", base_dn, ldb.SCOPE_SUBTREE, attrs, controls)
-    assertEquals(res.error, 0)
     assert(len(res) > 0)
 
     if gc_ldb is not None:
@@ -817,50 +815,42 @@ member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """
         attrs = ["cn"]
         controls = ["search_options:1:0"]
         res = gc_ldb.search("objectClass=crossRef", base_dn, gc_ldb.SCOPE_SUBTREE, attrs, controls)
-        assertEquals(res.error, 0)
         assert(len(res) > 0)
 
         print "Testing that we do find configuration elements in the global catlog"
         attrs = ["cn"]
         res = gc_ldb.search("objectClass=crossRef", base_dn, ldb.SCOPE_SUBTREE, attrs)
-        assertEquals(res.error, 0)
         assert (len(res) > 0)
     
         print "Testing that we do find configuration elements and user elements at the same time"
         attrs = ["cn"]
         res = gc_ldb.search("(|(objectClass=crossRef)(objectClass=person))", base_dn, ldb.SCOPE_SUBTREE, attrs)
-        assertEquals(res.error, 0)
         assert (len(res) > 0)
 
         print "Testing that we do find configuration elements in the global catlog, with the configuration basedn"
         attrs = ["cn"]
         res = gc_ldb.search("objectClass=crossRef", configuration_dn, ldb.SCOPE_SUBTREE, attrs)
-        assertEquals(res.error, 0)
         assert (len(res) > 0)
 
     print "Testing that we can get at the configuration DN on the main LDAP port"
     attrs = ["cn"]
     res = ldb.search("objectClass=crossRef", configuration_dn, ldb.SCOPE_SUBTREE, attrs)
-    assertEquals(res.error, 0)
     assert (len(res) > 0)
 
     print "Testing objectCategory canonacolisation"
     attrs = ["cn"]
     res = ldb.search("objectCategory=ntDsDSA", configuration_dn, ldb.SCOPE_SUBTREE, attrs)
-    assertEquals(res.error, 0)
     assert len(res) > 0, "Didn't find any records with objectCategory=ntDsDSA"
     assert(len(res) != 0)
     
     attrs = ["cn"]
     res = ldb.search("objectCategory=CN=ntDs-DSA," + schema_dn, configuration_dn, ldb.SCOPE_SUBTREE, attrs)
-    assertEquals(res.error, 0)
     assert len(res) > 0, "Didn't find any records with objectCategory=CN=ntDs-DSA," + schema_dn
     assert(len(res) != 0)
     
     print "Testing objectClass attribute order on "+ base_dn
-    attrs = ["objectClass"]
-    res = ldb.search("objectClass=domain", base_dn, ldb.SCOPE_BASE, attrs)
-    assertEquals(res.error, 0)
+    res = ldb.search(expression="objectClass=domain", base=base_dn, 
+                     scope=SCOPE_BASE, attrs=["objectClass"])
     assertEquals(len(res), 1)
 
     assertEquals(res[0].objectClass[0], "top")
@@ -872,88 +862,71 @@ member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """
     attrs = ["cn"]
     print "Testing ldb.search for objectCategory=person"
     res = ldb.search("objectCategory=person", base_dn, ldb.SCOPE_SUBTREE, attrs)
-    assertEquals(res.error, 0)
     assert(len(res) > 0)
 
     attrs = ["cn"]
     controls = ["domain_scope:1"]
     print "Testing ldb.search for objectCategory=person with domain scope control"
     res = ldb.search("objectCategory=person", base_dn, ldb.SCOPE_SUBTREE, attrs, controls)
-    assertEquals(res.error, 0)
     assert(len(res) > 0)
  
     attrs = ["cn"]
     print "Testing ldb.search for objectCategory=user"
     res = ldb.search("objectCategory=user", base_dn, ldb.SCOPE_SUBTREE, attrs)
-    assertEquals(res.error, 0)
     assert(len(res) > 0)
 
     attrs = ["cn"]
     controls = ["domain_scope:1"]
     print "Testing ldb.search for objectCategory=user with domain scope control"
     res = ldb.search("objectCategory=user", base_dn, ldb.SCOPE_SUBTREE, attrs, controls)
-    assertEquals(res.error, 0)
     assert(len(res) > 0)
     
     attrs = ["cn"]
     print "Testing ldb.search for objectCategory=group"
     res = ldb.search("objectCategory=group", base_dn, ldb.SCOPE_SUBTREE, attrs)
-    assertEquals(res.error, 0)
     assert(len(res) > 0)
 
     attrs = ["cn"]
     controls = ["domain_scope:1"]
     print "Testing ldb.search for objectCategory=group with domain scope control"
     res = ldb.search("objectCategory=group", base_dn, ldb.SCOPE_SUBTREE, attrs, controls)
-    assertEquals(res.error, 0)
     assert(len(res) > 0)
 
 def basedn_tests(ldb, gc_ldb):
     print "Testing for all rootDSE attributes"
-    attrs = []
-    res = ldb.search("", "", ldb.SCOPE_BASE, attrs)
-    assertEquals(res.error, 0)
+    res = ldb.search(scope=SCOPE_BASE, attrs=[])
     assertEquals(len(res), 1)
 
     print "Testing for highestCommittedUSN"
-    attrs = ["highestCommittedUSN"]
-    res = ldb.search("", "", ldb.SCOPE_BASE, attrs)
-    assertEquals(res.error, 0)
+    
+    res = ldb.search(scope=SCOPE_BASE, attrs=["highestCommittedUSN"])
     assertEquals(len(res), 1)
     assert(res[0].highestCommittedUSN != undefined)
     assert(res[0].highestCommittedUSN != 0)
 
     print "Testing for netlogon via LDAP"
-    attrs = ["netlogon"]
-    res = ldb.search("", "", ldb.SCOPE_BASE, attrs)
-    assertEquals(res.error, 0)
+    res = ldb.search(scope=SCOPE_BASE, attrs=["netlogon"])
     assertEquals(len(res), 0)
 
     print "Testing for netlogon and highestCommittedUSN via LDAP"
-    attrs = ["netlogon", "highestCommittedUSN"]
-    res = ldb.search("", "", ldb.SCOPE_BASE, attrs)
-    assertEquals(res.error, 0)
+    res = ldb.search(scope=SCOPE_BASE, 
+            attrs=["netlogon", "highestCommittedUSN"])
     assertEquals(len(res), 0)
 
 def find_basedn(ldb):
-    attrs = ["defaultNamingContext"]
-    res = ldb.search("", "", ldb.SCOPE_BASE, attrs)
-    assertEquals(res.error, 0)
+    res = ldb.search(scope=SCOPE_BASE, attrs=["defaultNamingContext"])
     assertEquals(len(res), 1)
-    return res[0].defaultNamingContext
+    return res[0]["defaultNamingContext"]
 
 def find_configurationdn(ldb):
-    attrs = ["configurationNamingContext"]
-    res = ldb.search("", "", ldb.SCOPE_BASE, attrs)
-    assertEquals(res.error, 0)
+    res = ldb.search(scope=SCOPE_BASE, attrs=["configurationNamingContext"])
     assertEquals(len(res), 1)
-    return res[0].configurationNamingContext
+    return res[0]["configurationNamingContext"]
 
 def find_schemadn(ldb):
-    res = ldb.search("", "", ldb.SCOPE_BASE, attrs=["schemaNamingContext"])
-    assertEquals(res.error, 0)
+    res = ldb.search(scope=SCOPE_BASE, attrs=["schemaNamingContext"])
     assertEquals(len(res), 1)
-    return res[0].schemaNamingContext
+    return res[0]["schemaNamingContext"]
 
 if not "://" in host:
     host = "ldap://%s" % host