From 1d8cdddcd0901c5886099b7596f6d9629bdfad69 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 11 Jan 2008 03:25:22 +0100 Subject: python/ldap: Support controls argument to ldb.search(). (This used to be commit 9eddc27f13fa2feb56d6b015e66d8c54081487da) --- source4/lib/ldb/ldb.i | 52 +++++++++++++- source4/lib/ldb/ldb.py | 10 ++- source4/lib/ldb/ldb_wrap.c | 133 ++++++++++++++++++++++++------------ source4/lib/ldb/tests/python/api.py | 22 +++--- 4 files changed, 162 insertions(+), 55 deletions(-) (limited to 'source4') diff --git a/source4/lib/ldb/ldb.i b/source4/lib/ldb/ldb.i index cf4a335954..2604393e8f 100644 --- a/source4/lib/ldb/ldb.i +++ b/source4/lib/ldb/ldb.i @@ -514,11 +514,49 @@ typedef struct ldb_context { const char *options[] = NULL); ~ldb() { talloc_free($self); } - ldb_error search(ldb_dn *base = NULL, + ldb_error search_ex(TALLOC_CTX *mem_ctx, + ldb_dn *base = NULL, enum ldb_scope scope = LDB_SCOPE_DEFAULT, const char *expression = NULL, - const char * const *attrs = NULL, - struct ldb_result **OUT); + const char *const *attrs = NULL, + struct ldb_control **controls = NULL, + struct ldb_result **OUT) { + int ret; + struct ldb_result *res; + struct ldb_request *req; + res = talloc_zero(mem_ctx, struct ldb_result); + if (!res) { + return LDB_ERR_OPERATIONS_ERROR; + } + + ret = ldb_build_search_req(&req, $self, mem_ctx, + base?base:ldb_get_default_basedn($self), + scope, + expression, + attrs, + controls, + res, + ldb_search_default_callback); + + if (ret != LDB_SUCCESS) { + talloc_free(res); + return ret; + } + + ldb_set_timeout($self, req, 0); /* use default timeout */ + + ret = ldb_request($self, req); + + if (ret == LDB_SUCCESS) { + ret = ldb_wait(req->handle, LDB_WAIT_ALL); + } + + talloc_free(req); + + *OUT = res; + return ret; + } + ldb_error delete(ldb_dn *dn); ldb_error rename(ldb_dn *olddn, ldb_dn *newdn); struct ldb_control **parse_control_strings(TALLOC_CTX *mem_ctx, @@ -615,6 +653,14 @@ typedef struct ldb_context { _ldb.Ldb_swiginit(self,_ldb.new_Ldb()) if url is not None: self.connect(url, flags, options) + + def search(self, base=None, scope=SCOPE_DEFAULT, expression=None, + attrs=None, controls=None): + parsed_controls = None + if controls is not None: + parsed_controls = self.parse_control_strings(controls) + return self.search_ex(base, scope, expression, attrs, + parsed_controls) } } ldb; diff --git a/source4/lib/ldb/ldb.py b/source4/lib/ldb/ldb.py index 5a921b5394..4cc8b5268a 100644 --- a/source4/lib/ldb/ldb.py +++ b/source4/lib/ldb/ldb.py @@ -192,8 +192,16 @@ class Ldb(object): if url is not None: self.connect(url, flags, options) + def search(self, base=None, scope=SCOPE_DEFAULT, expression=None, + attrs=None, controls=None): + parsed_controls = None + if controls is not None: + parsed_controls = self.parse_control_strings(controls) + return self.search_ex(base, scope, expression, attrs, + parsed_controls) + Ldb.connect = new_instancemethod(_ldb.Ldb_connect,None,Ldb) -Ldb.search = new_instancemethod(_ldb.Ldb_search,None,Ldb) +Ldb.search_ex = new_instancemethod(_ldb.Ldb_search_ex,None,Ldb) Ldb.delete = new_instancemethod(_ldb.Ldb_delete,None,Ldb) Ldb.rename = new_instancemethod(_ldb.Ldb_rename,None,Ldb) Ldb.parse_control_strings = new_instancemethod(_ldb.Ldb_parse_control_strings,None,Ldb) diff --git a/source4/lib/ldb/ldb_wrap.c b/source4/lib/ldb/ldb_wrap.c index 282a218a03..c833246ead 100644 --- a/source4/lib/ldb/ldb_wrap.c +++ b/source4/lib/ldb/ldb_wrap.c @@ -3047,6 +3047,42 @@ SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val) } SWIGINTERN void delete_ldb(ldb *self){ talloc_free(self); } +SWIGINTERN ldb_error ldb_search_ex(ldb *self,TALLOC_CTX *mem_ctx,ldb_dn *base,enum ldb_scope scope,char const *expression,char const *const *attrs,struct ldb_control **controls,struct ldb_result **OUT){ + int ret; + struct ldb_result *res; + struct ldb_request *req; + res = talloc_zero(mem_ctx, struct ldb_result); + if (!res) { + return 1; + } + + ret = ldb_build_search_req(&req, self, mem_ctx, + base?base:ldb_get_default_basedn(self), + scope, + expression, + attrs, + controls, + res, + ldb_search_default_callback); + + if (ret != 0) { + talloc_free(res); + return ret; + } + + ldb_set_timeout(self, req, 0); /* use default timeout */ + + ret = ldb_request(self, req); + + if (ret == 0) { + ret = ldb_wait(req->handle, LDB_WAIT_ALL); + } + + talloc_free(req); + + *OUT = res; + return ret; + } SWIGINTERN ldb_error ldb_add__SWIG_1(ldb *self,PyObject *py_msg){ ldb_error ret; int dict_pos, msg_pos; @@ -4354,95 +4390,108 @@ fail: } -SWIGINTERN PyObject *_wrap_Ldb_search(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { +SWIGINTERN PyObject *_wrap_Ldb_search_ex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; ldb *arg1 = (ldb *) 0 ; - ldb_dn *arg2 = (ldb_dn *) NULL ; - enum ldb_scope arg3 = (enum ldb_scope) LDB_SCOPE_DEFAULT ; - char *arg4 = (char *) NULL ; - char **arg5 = (char **) NULL ; - struct ldb_result **arg6 = (struct ldb_result **) 0 ; + TALLOC_CTX *arg2 = (TALLOC_CTX *) 0 ; + ldb_dn *arg3 = (ldb_dn *) NULL ; + enum ldb_scope arg4 = (enum ldb_scope) LDB_SCOPE_DEFAULT ; + char *arg5 = (char *) NULL ; + char **arg6 = (char **) NULL ; + struct ldb_control **arg7 = (struct ldb_control **) NULL ; + struct ldb_result **arg8 = (struct ldb_result **) 0 ; ldb_error result; void *argp1 = 0 ; int res1 = 0 ; - int val3 ; - int ecode3 = 0 ; - int res4 ; - char *buf4 = 0 ; - int alloc4 = 0 ; - struct ldb_result *temp_ldb_result6 ; - int i6 ; + int val4 ; + int ecode4 = 0 ; + int res5 ; + char *buf5 = 0 ; + int alloc5 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + struct ldb_result *temp_ldb_result8 ; + int i8 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; char * kwnames[] = { - (char *) "self",(char *) "base",(char *) "scope",(char *) "expression",(char *) "attrs", NULL + (char *) "self",(char *) "base",(char *) "scope",(char *) "expression",(char *) "attrs",(char *) "controls", NULL }; - arg6 = &temp_ldb_result6; - if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Ldb_search",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + arg2 = NULL; + arg8 = &temp_ldb_result8; + if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:Ldb_search_ex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_search" "', argument " "1"" of type '" "ldb *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_search_ex" "', argument " "1"" of type '" "ldb *""'"); } arg1 = (ldb *)(argp1); if (obj1) { - if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg2) != 0) { + if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg3) != 0) { SWIG_fail; } } if (obj2) { - ecode3 = SWIG_AsVal_int(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Ldb_search" "', argument " "3"" of type '" "enum ldb_scope""'"); + ecode4 = SWIG_AsVal_int(obj2, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Ldb_search_ex" "', argument " "4"" of type '" "enum ldb_scope""'"); } - arg3 = (enum ldb_scope)(val3); + arg4 = (enum ldb_scope)(val4); } if (obj3) { - res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Ldb_search" "', argument " "4"" of type '" "char const *""'"); + res5 = SWIG_AsCharPtrAndSize(obj3, &buf5, NULL, &alloc5); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Ldb_search_ex" "', argument " "5"" of type '" "char const *""'"); } - arg4 = (char *)(buf4); + arg5 = (char *)(buf5); } if (obj4) { if (obj4 == Py_None) { - arg5 = NULL; + arg6 = NULL; } else if (PySequence_Check(obj4)) { int i; - arg5 = talloc_array(NULL, char *, PySequence_Size(obj4)+1); + arg6 = talloc_array(NULL, char *, PySequence_Size(obj4)+1); for(i = 0; i < PySequence_Size(obj4); i++) - arg5[i] = PyString_AsString(PySequence_GetItem(obj4, i)); - arg5[i] = NULL; + arg6[i] = PyString_AsString(PySequence_GetItem(obj4, i)); + arg6[i] = NULL; } else { SWIG_exception(SWIG_TypeError, "expected sequence"); } } + if (obj5) { + res7 = SWIG_ConvertPtr(obj5, &argp7,SWIGTYPE_p_p_ldb_control, 0 | 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Ldb_search_ex" "', argument " "7"" of type '" "struct ldb_control **""'"); + } + arg7 = (struct ldb_control **)(argp7); + } if (arg1 == NULL) SWIG_exception(SWIG_ValueError, "ldb context must be non-NULL"); - result = ldb_search(arg1,arg2,arg3,(char const *)arg4,(char const *const *)arg5,arg6); + result = ldb_search_ex(arg1,arg2,arg3,arg4,(char const *)arg5,(char const *const *)arg6,arg7,arg8); if (result != 0) { PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_strerror(result))); SWIG_fail; } resultobj = Py_None; - resultobj = PyList_New((*arg6)->count); - for (i6 = 0; i6 < (*arg6)->count; i6++) { - PyList_SetItem(resultobj, i6, - SWIG_NewPointerObj((*arg6)->msgs[i6], SWIGTYPE_p_ldb_message, 0) + resultobj = PyList_New((*arg8)->count); + for (i8 = 0; i8 < (*arg8)->count; i8++) { + PyList_SetItem(resultobj, i8, + SWIG_NewPointerObj((*arg8)->msgs[i8], SWIGTYPE_p_ldb_message, 0) ); } - talloc_free(arg2); - if (alloc4 == SWIG_NEWOBJ) free((char*)buf4); - talloc_free(arg5); + talloc_free(arg3); + if (alloc5 == SWIG_NEWOBJ) free((char*)buf5); + talloc_free(arg6); return resultobj; fail: - talloc_free(arg2); - if (alloc4 == SWIG_NEWOBJ) free((char*)buf4); - talloc_free(arg5); + talloc_free(arg3); + if (alloc5 == SWIG_NEWOBJ) free((char*)buf5); + talloc_free(arg6); return NULL; } @@ -5395,7 +5444,7 @@ static PyMethodDef SwigMethods[] = { { (char *)"new_Ldb", (PyCFunction)_wrap_new_Ldb, METH_NOARGS, NULL}, { (char *)"Ldb_connect", (PyCFunction) _wrap_Ldb_connect, METH_VARARGS | METH_KEYWORDS, NULL}, { (char *)"delete_Ldb", (PyCFunction)_wrap_delete_Ldb, METH_O, NULL}, - { (char *)"Ldb_search", (PyCFunction) _wrap_Ldb_search, METH_VARARGS | METH_KEYWORDS, NULL}, + { (char *)"Ldb_search_ex", (PyCFunction) _wrap_Ldb_search_ex, METH_VARARGS | METH_KEYWORDS, NULL}, { (char *)"Ldb_delete", (PyCFunction) _wrap_Ldb_delete, METH_VARARGS | METH_KEYWORDS, NULL}, { (char *)"Ldb_rename", (PyCFunction) _wrap_Ldb_rename, METH_VARARGS | METH_KEYWORDS, NULL}, { (char *)"Ldb_parse_control_strings", (PyCFunction) _wrap_Ldb_parse_control_strings, METH_VARARGS | METH_KEYWORDS, NULL}, diff --git a/source4/lib/ldb/tests/python/api.py b/source4/lib/ldb/tests/python/api.py index 236698e382..b071b84b19 100755 --- a/source4/lib/ldb/tests/python/api.py +++ b/source4/lib/ldb/tests/python/api.py @@ -48,6 +48,10 @@ class SimpleLdb(unittest.TestCase): l = ldb.Ldb("foo.tdb") self.assertEquals(len(l.search()), 1) + def test_search_controls(self): + l = ldb.Ldb("foo.tdb") + self.assertEquals(len(l.search(controls=["paged_results:1:5"])), 1) + def test_search_attrs(self): l = ldb.Ldb("foo.tdb") self.assertEquals(len(l.search(ldb.Dn(l, ""), ldb.SCOPE_SUBTREE, "(dc=*)", ["dc"])), 0) @@ -167,54 +171,54 @@ class SimpleLdb(unittest.TestCase): def test_modify_delete(self): l = ldb.Ldb("foo.tdb") m = ldb.Message() - m.dn = ldb.Dn(l, "dc=modify") + m.dn = ldb.Dn(l, "dc=modifydelete") m["bla"] = ["1234"] l.add(m) rm = l.search(m.dn)[0] self.assertEquals(["1234"], list(rm["bla"])) try: m = ldb.Message() - m.dn = ldb.Dn(l, "dc=modify") + m.dn = ldb.Dn(l, "dc=modifydelete") m["bla"] = ldb.MessageElement([], ldb.CHANGETYPE_DELETE, "bla") l.modify(m) rm = l.search(m.dn)[0] self.assertEquals(1, len(rm)) finally: - l.delete(ldb.Dn(l, "dc=modify")) + l.delete(ldb.Dn(l, "dc=modifydelete")) def test_modify_add(self): l = ldb.Ldb("foo.tdb") m = ldb.Message() - m.dn = ldb.Dn(l, "dc=modify") + m.dn = ldb.Dn(l, "dc=add") m["bla"] = ["1234"] l.add(m) try: m = ldb.Message() - m.dn = ldb.Dn(l, "dc=modify") + m.dn = ldb.Dn(l, "dc=add") m["bla"] = ldb.MessageElement(["456"], ldb.CHANGETYPE_ADD, "bla") l.modify(m) rm = l.search(m.dn)[0] self.assertEquals(2, len(rm)) self.assertEquals(["1234", "456"], list(rm["bla"])) finally: - l.delete(ldb.Dn(l, "dc=modify")) + l.delete(ldb.Dn(l, "dc=add")) def test_modify_modify(self): l = ldb.Ldb("foo.tdb") m = ldb.Message() - m.dn = ldb.Dn(l, "dc=modify") + m.dn = ldb.Dn(l, "dc=modify2") m["bla"] = ["1234", "456"] l.add(m) try: m = ldb.Message() - m.dn = ldb.Dn(l, "dc=modify") + m.dn = ldb.Dn(l, "dc=modify2") m["bla"] = ldb.MessageElement(["456"], ldb.CHANGETYPE_MODIFY, "bla") l.modify(m) rm = l.search(m.dn)[0] self.assertEquals(2, len(rm)) self.assertEquals(["1234"], list(rm["bla"])) finally: - l.delete(ldb.Dn(l, "dc=modify")) + l.delete(ldb.Dn(l, "dc=modify2")) def test_transaction_commit(self): l = ldb.Ldb("foo.tdb") -- cgit From aec66711779b567e2e2052ff223b67dba5796419 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 10 Jan 2008 20:17:03 +0100 Subject: python: No longer skip LDAP tests. (This used to be commit d029c0bedf8b3d300050786991e2df0e446fca72) --- source4/samba4-skip | 1 - 1 file changed, 1 deletion(-) (limited to 'source4') diff --git a/source4/samba4-skip b/source4/samba4-skip index 99c1799a7a..8ce9c4f9cc 100644 --- a/source4/samba4-skip +++ b/source4/samba4-skip @@ -49,5 +49,4 @@ RPC-FRSAPI # Not provided by Samba 4 ^samba4.NET-API-BECOME-DC.*$ # Fails WINBIND # FIXME: This should not be skipped NSS-TEST # Fails -samba4.ldap.python # Conversion from EJS not yet finished samba4.samba3sam.python # Conversion from EJS not yet finished -- cgit From a785df0c0aeaf59d5a19cfc816dd909bded1222b Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 10 Jan 2008 23:06:14 +0100 Subject: ldap/python: Fix some more calls. (This used to be commit 583881ae5a2a173abad9ba1ffd766b009d9ca8cd) --- source4/lib/ldb/tests/python/ldap.py | 121 ++++++++++++++--------------------- 1 file changed, 47 insertions(+), 74 deletions(-) (limited to 'source4') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index 3f70ef9b43..1e7ed48d07 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/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 -- cgit From 410e8f8681c55af21a735a7c51aac5edd877fab0 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 10 Jan 2008 23:37:35 +0100 Subject: python: Specify right arguments for the ldap test, fix some more calls. (This used to be commit 74209fa6b097c6cd3c919dc6a67d998de12fa575) --- source4/lib/ldb/tests/python/ldap.py | 67 ++++++++++++++++-------------------- source4/selftest/samba4_tests.sh | 2 +- 2 files changed, 31 insertions(+), 38 deletions(-) (limited to 'source4') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index 1e7ed48d07..7f1e5ad8f3 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/lib/ldb/tests/python/ldap.py @@ -551,8 +551,8 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """ assertEquals(res[0].objectClass[1], "person") assertEquals(res[0].objectClass[2], "organizationalPerson") assertEquals(res[0].objectClass[3], "user") - assert(res[0].objectGUID != undefined) - assert(res[0].whenCreated != undefined) + assert("objectGUID" not in res[0]) + assert("whenCreated" not in res[0]) assertEquals(res[0].objectCategory, ("CN=Person,CN=Schema,CN=Configuration," + base_dn)) assertEquals(res[0].sAMAccountType, 805306368) # assertEquals(res[0].userAccountControl, 546) @@ -600,8 +600,8 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """ assertEquals(res[0].objectClass[2], "organizationalPerson") assertEquals(res[0].objectClass[3], "user") assertEquals(res[0].objectClass[4], "computer") - assert(res[0].objectGUID != undefined) - assert(res[0].whenCreated != undefined) + assert("objectGUID" not in res[0]) + assert("whenCreated" not in res[0]) assertEquals(res[0].objectCategory, ("CN=Computer,CN=Schema,CN=Configuration," + base_dn)) assertEquals(res[0].primaryGroupID, 513) # assertEquals(res[0].sAMAccountType, 805306368) @@ -667,17 +667,17 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """ assertEquals(res[0].objectClass[2], "organizationalPerson") assertEquals(res[0].objectClass[3], "user") assertEquals(res[0].objectClass[4], "computer") - assert(res[0].objectGUID != undefined) - assert(res[0].whenCreated != undefined) - assertEquals(res[0].objectCategory, "cn=Computer,cn=Schema,cn=Configuration," + base_dn) - assertEquals(res[0].sAMAccountType, 805306369) + assert("objectGUID" not in res[0]) + assert("whenCreated" not in res[0]) + assertEquals(res[0]["objectCategory"], "cn=Computer,cn=Schema,cn=Configuration," + base_dn) + assertEquals(int(res[0]["sAMAccountType"]), 805306369) # assertEquals(res[0].userAccountControl, 4098) ldb.delete(res[0].dn) attrs = ["cn", "name", "objectClass", "objectGUID", "whenCreated", "nTSecurityDescriptor", "memberOf"] print "Testing ldb.search for (&(cn=ldaptestUSer2)(objectClass=user))" - res = ldb.search(base_dn, "(&(cn=ldaptestUSer2)(objectClass=user))", ldb.SCOPE_SUBTREE, attrs) + res = ldb.search(base_dn, "(&(cn=ldaptestUSer2)(objectClass=user))", scope=SCOPE_SUBTREE, attrs=attrs) assert len(res) == 1, "Could not find (&(cn=ldaptestUSer2)(objectClass=user))" assertEquals(res[0].dn, ("CN=ldaptestuser2,CN=Users," + base_dn)) @@ -687,14 +687,14 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """ assertEquals(res[0].objectClass[1], "person") assertEquals(res[0].objectClass[2], "organizationalPerson") assertEquals(res[0].objectClass[3], "user") - assert(res[0].objectGUID != undefined) - assert(res[0].whenCreated != undefined) - assert(res[0].nTSecurityDescriptor != undefined) + assert("objectGUID" not in res[0]) + assert("whenCreated" not in res[0]) + assert("nTSecurityDescriptor" not in res[0]) assertEquals(res[0].memberOf[0], ("CN=ldaptestgroup2,CN=Users," + base_dn)) attrs = ["cn", "name", "objectClass", "objectGUID", "whenCreated", "nTSecurityDescriptor", "member"] print "Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group))" - res = ldb.search("(&(cn=ldaptestgroup2)(objectClass=group))", base_dn, ldb.SCOPE_SUBTREE, attrs) + res = ldb.search(base_dn, "(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs) assert len(res) == 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))" assertEquals(res[0].dn, ("CN=ldaptestgroup2,CN=Users," + base_dn)) @@ -702,11 +702,11 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """ assertEquals(res[0].name, "ldaptestgroup2") assertEquals(res[0].objectClass[0], "top") assertEquals(res[0].objectClass[1], "group") - assert(res[0].objectGUID != undefined) - assert(res[0].whenCreated != undefined) - assert(res[0].nTSecurityDescriptor != undefined) + assert("objectGuid" not in res[0]) + assert("whenCreated" not in res[0]) + assert("nTSecurityDescriptor" not in res[0]) assertEquals(res[0].member[0], ("CN=ldaptestuser2,CN=Users," + base_dn)) - assertEquals(res[0].member.length, 1) + assertEquals(len(res[0].member), 1) ldb.modify_ldif(""" dn: cn=ldaptestgroup2,cn=users,""" + base_dn + """ @@ -752,7 +752,7 @@ delete: member member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """ """) - res = ldb.search("(&(cn=ldaptestgroup2)(objectClass=group))", base_dn, ldb.SCOPE_SUBTREE, attrs) + res = ldb.search(base_dn, "(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs) assert len(res) != 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))" assertEquals(res[0].dn, ("CN=ldaptestgroup2,CN=Users," + base_dn)) @@ -763,11 +763,11 @@ member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """ attrs = ["cn", "name", "objectClass", "objectGUID", "whenCreated", "nTSecurityDescriptor", "member"] print "Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete" - res = ldb.search("(&(cn=ldaptestgroup2)(objectClass=group))", base_dn, ldb.SCOPE_SUBTREE, attrs) + res = ldb.search(base_dn, "(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs) assert len(res) != 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete" - assertEquals(res[0].dn, ("CN=ldaptestgroup2,CN=Users," + base_dn)) - assertEquals(res[0].member, undefined) + assertEquals(res[0]["dn"], ("CN=ldaptestgroup2,CN=Users," + base_dn)) + assert("member" not in res[0]) print "Testing ldb.search for (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))" res = ldb.search("(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))") @@ -780,8 +780,8 @@ member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """ assertEquals(res[0].objectClass[1], "person") assertEquals(res[0].objectClass[2], "organizationalPerson") assertEquals(res[0].objectClass[3], "user") - assert(res[0].objectGUID != undefined) - assert(res[0].whenCreated != undefined) + assert("objectGUID" not in res[0]) + assert("whenCreated" not in res[0]) ldb.delete(res[0].dn) @@ -794,20 +794,17 @@ member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """ ldb.delete(("CN=ldaptestgroup2,CN=Users," + base_dn)) print "Testing ldb.search for (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))" - res = ldb.search("(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))") + res = ldb.search(expression="(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))") assert len(res) == 1, "Could not find (expect space collapse, win2k3 fails) (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))" 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) + res = ldb.search(base_dn, "objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"]) 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) print "Testing that we can get at the configuration DN from the main search base on the LDAP port with the 'phantom root' search_options control" - attrs = ["cn"] - controls = ["search_options:1:2"] - res = ldb.search("objectClass=crossRef", base_dn, ldb.SCOPE_SUBTREE, attrs, controls) + res = ldb.search(base_dn, "objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:2"]) assert(len(res) > 0) if gc_ldb is not None: @@ -818,18 +815,15 @@ member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """ 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) + res = gc_ldb.search(base_dn, "objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"]) 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) + res = gc_ldb.search(base_dn, "(|(objectClass=crossRef)(objectClass=person))", scope=SCOPE_SUBTREE, attrs=["cn"]) 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) + res = gc_ldb.search(configuration_dn, "objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"]) assert (len(res) > 0) print "Testing that we can get at the configuration DN on the main LDAP port" @@ -901,8 +895,7 @@ def basedn_tests(ldb, gc_ldb): res = ldb.search(scope=SCOPE_BASE, attrs=["highestCommittedUSN"]) assertEquals(len(res), 1) - assert(res[0].highestCommittedUSN != undefined) - assert(res[0].highestCommittedUSN != 0) + assert(res[0]["highestCommittedUSN"] != 0) print "Testing for netlogon via LDAP" res = ldb.search(scope=SCOPE_BASE, attrs=["netlogon"]) diff --git a/source4/selftest/samba4_tests.sh b/source4/selftest/samba4_tests.sh index 290c06fa6a..e7d04bfdb2 100755 --- a/source4/selftest/samba4_tests.sh +++ b/source4/selftest/samba4_tests.sh @@ -322,7 +322,7 @@ then plantest "samba3.python" none $SUBUNITRUN samba.tests.samba3 plantest "events.python" none PYTHONPATH="$PYTHONPATH:lib/events" $SUBUNITRUN tests plantest "samba3sam.python" none PYTHONPATH="$PYTHONPATH:dsdb/samdb/ldb_modules/tests" $SUBUNITRUN samba3sam - plantest "ldap.python" dc $PYTHON $samba4srcdir/lib/ldb/tests/python/ldap.py \$SERVER -U\$USERNAME%\$PASSWORD + plantest "ldap.python" dc $PYTHON $samba4srcdir/lib/ldb/tests/python/ldap.py $CONFIGURATION -d 10 \$SERVER -U\$USERNAME%\$PASSWORD plantest "blackbox.samba3dump" none $PYTHON scripting/bin/samba3dump $samba4srcdir/../testdata/samba3 rm -rf $PREFIX/upgrade plantest "blackbox.upgrade" none $PYTHON setup/upgrade.py $CONFIGURATION --targetdir=$PREFIX/upgrade ../testdata/samba3 ../testdata/samba3/smb.conf -- cgit From b344508ca3d071a1e4ba046f2fdac07ce01bb097 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 11 Jan 2008 00:22:23 +0100 Subject: python: More work getting the LDAP test to compile again. (This used to be commit d7a3f9612c40000cb265279598c09f6983305656) --- source4/lib/ldb/tests/python/ldap.py | 59 ++++++++++++++---------------------- source4/selftest/samba4_tests.sh | 2 +- 2 files changed, 24 insertions(+), 37 deletions(-) (limited to 'source4') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index 7f1e5ad8f3..0f3e21573b 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/lib/ldb/tests/python/ldap.py @@ -177,11 +177,11 @@ servicePrincipalName: host/ldaptest2computer28 servicePrincipalName: host/ldaptest2computer29 """) - res = ldb.search(base_dn, expression="(cn=ldaptest2computer))", scope=ldb.SCOPE_SUBTREE, + res = ldb.search(base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-*"]) assert len(res) == 1, "Could not find (cn=ldaptest2computer)" # print res[0]["servicePrincipalName;range=0-*"].length - assertEquals(res[0]["servicePrincipalName;range=0-*"].length, 30) + assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30) attrs = ["servicePrincipalName;range=0-19"] res = ldb.search(base_dn, "(cn=ldaptest2computer))", SCOPE_SUBTREE, attrs) @@ -579,9 +579,8 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """ assertEquals(res[0].dn, res3gc.msgs[0].dn) print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon)) in with 'phantom root' control" - attrs = ["cn"] - controls = ["search_options:1:2"] - res3control = gc_ldb.search("(&(cn=ldaptestuser)(objectCategory=PerSon))", base_dn, ldb.SCOPE_SUBTREE, attrs, controls) + + res3control = gc_ldb.search(base_dn, "(&(cn=ldaptestuser)(objectCategory=PerSon))", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:2"]) assert len(res3control) == 1, "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog" assertEquals(res[0].dn, res3control.msgs[0].dn) @@ -809,9 +808,8 @@ member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """ if gc_ldb is not None: print "Testing that we can get at the configuration DN from the main search base on the GC port with the search_options control == 0" - attrs = ["cn"] - controls = ["search_options:1:0"] - res = gc_ldb.search("objectClass=crossRef", base_dn, gc_ldb.SCOPE_SUBTREE, attrs, controls) + + res = gc_ldb.search(base_dn, "objectClass=crossRef", SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:0"]) assert(len(res) > 0) print "Testing that we do find configuration elements in the global catlog" @@ -827,18 +825,15 @@ member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """ 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) + res = ldb.search(configuration_dn, "objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"]) assert (len(res) > 0) print "Testing objectCategory canonacolisation" - attrs = ["cn"] - res = ldb.search("objectCategory=ntDsDSA", configuration_dn, ldb.SCOPE_SUBTREE, attrs) + res = ldb.search(configuration_dn, "objectCategory=ntDsDSA", scope=SCOPE_SUBTREE, attrs=["cn"]) 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) + res = ldb.search(configuration_dn, "objectCategory=CN=ntDs-DSA," + schema_dn, scope=SCOPE_SUBTREE, attrs=["cn"]) assert len(res) > 0, "Didn't find any records with objectCategory=CN=ntDs-DSA," + schema_dn assert(len(res) != 0) @@ -853,37 +848,29 @@ member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """ # check enumeration - attrs = ["cn"] print "Testing ldb.search for objectCategory=person" - res = ldb.search("objectCategory=person", base_dn, ldb.SCOPE_SUBTREE, attrs) + res = ldb.search(base_dn, "objectCategory=person", scope=SCOPE_SUBTREE, attrs=["cn"]) 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) + res = ldb.search(base_dn, "objectCategory=person", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"]) assert(len(res) > 0) - attrs = ["cn"] print "Testing ldb.search for objectCategory=user" - res = ldb.search("objectCategory=user", base_dn, ldb.SCOPE_SUBTREE, attrs) + res = ldb.search(base_dn, "objectCategory=user", scope=SCOPE_SUBTREE, attrs=["cn"]) 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) + res = ldb.search(base_dn, "objectCategory=user", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"]) assert(len(res) > 0) - attrs = ["cn"] print "Testing ldb.search for objectCategory=group" - res = ldb.search("objectCategory=group", base_dn, ldb.SCOPE_SUBTREE, attrs) + res = ldb.search(base_dn, "objectCategory=group", scope=SCOPE_SUBTREE, attrs=["cn"]) 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) + res = ldb.search(base_dn, "objectCategory=group", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"]) assert(len(res) > 0) def basedn_tests(ldb, gc_ldb): @@ -907,19 +894,20 @@ def basedn_tests(ldb, gc_ldb): assertEquals(len(res), 0) def find_basedn(ldb): - res = ldb.search(scope=SCOPE_BASE, attrs=["defaultNamingContext"]) + res = ldb.search(base="", expression="", scope=SCOPE_BASE, + attrs=["defaultNamingContext"]) assertEquals(len(res), 1) - return res[0]["defaultNamingContext"] + return str(res[0]["defaultNamingContext"]) def find_configurationdn(ldb): - res = ldb.search(scope=SCOPE_BASE, attrs=["configurationNamingContext"]) + res = ldb.search(base="", expression="", scope=SCOPE_BASE, attrs=["configurationNamingContext"]) assertEquals(len(res), 1) - return res[0]["configurationNamingContext"] + return str(res[0]["configurationNamingContext"]) def find_schemadn(ldb): - res = ldb.search(scope=SCOPE_BASE, attrs=["schemaNamingContext"]) + res = ldb.search(base="", expression="", scope=SCOPE_BASE, attrs=["schemaNamingContext"]) assertEquals(len(res), 1) - return res[0]["schemaNamingContext"] + return str(res[0]["schemaNamingContext"]) if not "://" in host: host = "ldap://%s" % host @@ -927,7 +915,6 @@ if not "://" in host: ldb = Ldb(host, credentials=creds, session_info=system_session(), lp=lp) base_dn = find_basedn(ldb) - configuration_dn = find_configurationdn(ldb) schema_dn = find_schemadn(ldb) diff --git a/source4/selftest/samba4_tests.sh b/source4/selftest/samba4_tests.sh index e7d04bfdb2..4856265f73 100755 --- a/source4/selftest/samba4_tests.sh +++ b/source4/selftest/samba4_tests.sh @@ -322,7 +322,7 @@ then plantest "samba3.python" none $SUBUNITRUN samba.tests.samba3 plantest "events.python" none PYTHONPATH="$PYTHONPATH:lib/events" $SUBUNITRUN tests plantest "samba3sam.python" none PYTHONPATH="$PYTHONPATH:dsdb/samdb/ldb_modules/tests" $SUBUNITRUN samba3sam - plantest "ldap.python" dc $PYTHON $samba4srcdir/lib/ldb/tests/python/ldap.py $CONFIGURATION -d 10 \$SERVER -U\$USERNAME%\$PASSWORD + plantest "ldap.python" dc $PYTHON $samba4srcdir/lib/ldb/tests/python/ldap.py $CONFIGURATION \$SERVER -U\$USERNAME%\$PASSWORD plantest "blackbox.samba3dump" none $PYTHON scripting/bin/samba3dump $samba4srcdir/../testdata/samba3 rm -rf $PREFIX/upgrade plantest "blackbox.upgrade" none $PYTHON setup/upgrade.py $CONFIGURATION --targetdir=$PREFIX/upgrade ../testdata/samba3 ../testdata/samba3/smb.conf -- cgit From 5967746c3102b57bcf245a30d0969c90944305a3 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 11 Jan 2008 00:32:31 +0100 Subject: python/ldap: Fix some tests. (This used to be commit 52f64afd4324eb185303ca192b88ccb632ee8587) --- source4/lib/ldb/tests/python/ldap.py | 24 +++++++++++++++--------- 1 file changed, 15 insertions(+), 9 deletions(-) (limited to 'source4') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index 0f3e21573b..7e3082fa09 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/lib/ldb/tests/python/ldap.py @@ -11,7 +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 ldb import SCOPE_SUBTREE, SCOPE_ONELEVEL, SCOPE_BASE, LdbError from samba import Ldb import param @@ -40,8 +40,15 @@ def assertEquals(a1, a2): def basic_tests(ldb, gc_ldb, base_dn, configuration_dn, schema_dn): print "Running basic tests" - ldb.delete("cn=ldaptestuser,cn=users," + base_dn) - ldb.delete("cn=ldaptestgroup,cn=users," + base_dn) + try: + ldb.delete("cn=ldaptestuser,cn=users," + base_dn) + except LdbError, (num, _): + assert num == 32 # LDAP_NO_SUCH_OBJECT + + try: + ldb.delete("cn=ldaptestgroup,cn=users," + base_dn) + except LdbError, (num, _): + assert num == 32 # LDAP_NO_SUCH_OBJECT print "Testing group add with invalid member" try: @@ -50,7 +57,7 @@ def basic_tests(ldb, gc_ldb, base_dn, configuration_dn, schema_dn): "objectclass": "group", "member": "cn=ldaptestuser,cn=useRs," + base_dn}) except LdbError, (num, _): - assert error == 32 # LDAP_NO_SUCH_OBJECT + assert num == 32 # LDAP_NO_SUCH_OBJECT else: assert False @@ -897,23 +904,22 @@ def find_basedn(ldb): res = ldb.search(base="", expression="", scope=SCOPE_BASE, attrs=["defaultNamingContext"]) assertEquals(len(res), 1) - return str(res[0]["defaultNamingContext"]) + return res[0]["defaultNamingContext"][0] def find_configurationdn(ldb): res = ldb.search(base="", expression="", scope=SCOPE_BASE, attrs=["configurationNamingContext"]) assertEquals(len(res), 1) - return str(res[0]["configurationNamingContext"]) + return res[0]["configurationNamingContext"][0] def find_schemadn(ldb): res = ldb.search(base="", expression="", scope=SCOPE_BASE, attrs=["schemaNamingContext"]) assertEquals(len(res), 1) - return str(res[0]["schemaNamingContext"]) + return res[0]["schemaNamingContext"][0] if not "://" in host: host = "ldap://%s" % host -ldb = Ldb(host, credentials=creds, session_info=system_session(), - lp=lp) +ldb = Ldb(host, credentials=creds, session_info=system_session(), lp=lp) base_dn = find_basedn(ldb) configuration_dn = find_configurationdn(ldb) schema_dn = find_schemadn(ldb) -- cgit From da56ee66b07c7fcc8acedc8b7950501d7f065481 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 11 Jan 2008 01:01:36 +0100 Subject: python/ldap: Get further. (This used to be commit 0c27eabbc40657493dc72f12b4fbdb07b0a3200f) --- source4/lib/ldb/tests/python/ldap.py | 6 ++++-- source4/selftest/samba4_tests.sh | 2 +- 2 files changed, 5 insertions(+), 3 deletions(-) (limited to 'source4') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index 7e3082fa09..3d69ff63b4 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/lib/ldb/tests/python/ldap.py @@ -187,7 +187,7 @@ servicePrincipalName: host/ldaptest2computer29 res = ldb.search(base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-*"]) assert len(res) == 1, "Could not find (cn=ldaptest2computer)" -# print res[0]["servicePrincipalName;range=0-*"].length + #print len(res[0]["servicePrincipalName;range=0-*"]) assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30) attrs = ["servicePrincipalName;range=0-19"] @@ -886,7 +886,6 @@ def basedn_tests(ldb, gc_ldb): assertEquals(len(res), 1) print "Testing for highestCommittedUSN" - res = ldb.search(scope=SCOPE_BASE, attrs=["highestCommittedUSN"]) assertEquals(len(res), 1) assert(res[0]["highestCommittedUSN"] != 0) @@ -900,17 +899,20 @@ def basedn_tests(ldb, gc_ldb): attrs=["netlogon", "highestCommittedUSN"]) assertEquals(len(res), 0) + def find_basedn(ldb): res = ldb.search(base="", expression="", scope=SCOPE_BASE, attrs=["defaultNamingContext"]) assertEquals(len(res), 1) return res[0]["defaultNamingContext"][0] + def find_configurationdn(ldb): res = ldb.search(base="", expression="", scope=SCOPE_BASE, attrs=["configurationNamingContext"]) assertEquals(len(res), 1) return res[0]["configurationNamingContext"][0] + def find_schemadn(ldb): res = ldb.search(base="", expression="", scope=SCOPE_BASE, attrs=["schemaNamingContext"]) assertEquals(len(res), 1) diff --git a/source4/selftest/samba4_tests.sh b/source4/selftest/samba4_tests.sh index 4856265f73..11daa4bd59 100755 --- a/source4/selftest/samba4_tests.sh +++ b/source4/selftest/samba4_tests.sh @@ -322,7 +322,7 @@ then plantest "samba3.python" none $SUBUNITRUN samba.tests.samba3 plantest "events.python" none PYTHONPATH="$PYTHONPATH:lib/events" $SUBUNITRUN tests plantest "samba3sam.python" none PYTHONPATH="$PYTHONPATH:dsdb/samdb/ldb_modules/tests" $SUBUNITRUN samba3sam - plantest "ldap.python" dc $PYTHON $samba4srcdir/lib/ldb/tests/python/ldap.py $CONFIGURATION \$SERVER -U\$USERNAME%\$PASSWORD + plantest "ldap.python" dc $PYTHON $samba4srcdir/lib/ldb/tests/python/ldap.py $CONFIGURATION \$SERVER -U\$USERNAME%\$PASSWORD -W \$DOMAIN plantest "blackbox.samba3dump" none $PYTHON scripting/bin/samba3dump $samba4srcdir/../testdata/samba3 rm -rf $PREFIX/upgrade plantest "blackbox.upgrade" none $PYTHON setup/upgrade.py $CONFIGURATION --targetdir=$PREFIX/upgrade ../testdata/samba3 ../testdata/samba3/smb.conf -- cgit From d2b96bbec06d2b979e8fa8d4fd386523232d0be5 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 11 Jan 2008 01:47:32 +0100 Subject: Make a few more tests pass. (This used to be commit 017aa400c7097cf6132f2bec969b9bbb5237f4d8) --- source4/lib/ldb/tests/python/ldap.py | 244 +++++++++++++++++------------------ 1 file changed, 115 insertions(+), 129 deletions(-) (limited to 'source4') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index 3d69ff63b4..591277eb20 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/lib/ldb/tests/python/ldap.py @@ -34,21 +34,21 @@ lp = param.LoadParm() if opts.configfile: lp.load(opts.configfile) +def delete_force(ldb, dn): + try: + ldb.delete(dn) + except LdbError, (num, _): + if num != 32: # LDAP_NO_SUCH_OBJECT + assert False + def assertEquals(a1, a2): assert a1 == a2 def basic_tests(ldb, gc_ldb, base_dn, configuration_dn, schema_dn): print "Running basic tests" - try: - ldb.delete("cn=ldaptestuser,cn=users," + base_dn) - except LdbError, (num, _): - assert num == 32 # LDAP_NO_SUCH_OBJECT - - try: - ldb.delete("cn=ldaptestgroup,cn=users," + base_dn) - except LdbError, (num, _): - assert num == 32 # LDAP_NO_SUCH_OBJECT + delete_force(ldb, "cn=ldaptestuser,cn=users," + base_dn) + delete_force(ldb, "cn=ldaptestgroup,cn=users," + base_dn) print "Testing group add with invalid member" try: @@ -56,8 +56,9 @@ def basic_tests(ldb, gc_ldb, base_dn, configuration_dn, schema_dn): "dn": "cn=ldaptestgroup,cn=uSers," + base_dn, "objectclass": "group", "member": "cn=ldaptestuser,cn=useRs," + base_dn}) - except LdbError, (num, _): - assert num == 32 # LDAP_NO_SUCH_OBJECT + except LdbError, (num, _): + if num != 32: # LDAP_NO_SUCH_OBJECT + assert False else: assert False @@ -190,53 +191,47 @@ servicePrincipalName: host/ldaptest2computer29 #print len(res[0]["servicePrincipalName;range=0-*"]) assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30) - attrs = ["servicePrincipalName;range=0-19"] - res = ldb.search(base_dn, "(cn=ldaptest2computer))", SCOPE_SUBTREE, attrs) + res = ldb.search(base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-19"]) 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) + assertEquals(len(res[0]["servicePrincipalName;range=0-19"]), 20) - attrs = ["servicePrincipalName;range=0-30"] - res = ldb.search(base_dn, "(cn=ldaptest2computer))", SCOPE_SUBTREE, attrs) + + res = ldb.search(base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-30"]) assert len(res) == 1, "Could not find (cn=ldaptest2computer)" - assertEquals(res[0]["servicePrincipalName;range=0-*"].length, 30) + assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30) - attrs = ["servicePrincipalName;range=0-40"] - res = ldb.search(base_dn, "(cn=ldaptest2computer))", SCOPE_SUBTREE, attrs) + res = ldb.search(base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-40"]) assert len(res) == 1, "Could not find (cn=ldaptest2computer)" - assertEquals(res[0]["servicePrincipalName;range=0-*"].length, 30) + assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30) - attrs = ["servicePrincipalName;range=30-40"] - res = ldb.search(base_dn, "(cn=ldaptest2computer))", SCOPE_SUBTREE, attrs) + res = ldb.search(base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=30-40"]) assert len(res) == 1, "Could not find (cn=ldaptest2computer)" - assertEquals(res[0]["servicePrincipalName;range=30-*"].length, 0) + assertEquals(len(res[0]["servicePrincipalName;range=30-*"]), 0) - attrs = ["servicePrincipalName;range=10-40"] - res = ldb.search(base_dn, "(cn=ldaptest2computer))", SCOPE_SUBTREE, attrs) + + res = ldb.search(base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=10-40"]) assert len(res) == 1, "Could not find (cn=ldaptest2computer)" - assertEquals(res[0]["servicePrincipalName;range=10-*"].length, 20) + assertEquals(len(res[0]["servicePrincipalName;range=10-*"]), 20) # pos_11 = res[0]["servicePrincipalName;range=10-*"][18] - attrs = ["servicePrincipalName;range=11-40"] - res = ldb.search(base_dn, "(cn=ldaptest2computer))", SCOPE_SUBTREE, attrs) + res = ldb.search(base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=11-40"]) assert len(res) == 1, "Could not find (cn=ldaptest2computer)" - assertEquals(res[0]["servicePrincipalName;range=11-*"].length, 19) + assertEquals(len(res[0]["servicePrincipalName;range=11-*"]), 19) # print res[0]["servicePrincipalName;range=11-*"][18] # print pos_11 # assertEquals((res[0]["servicePrincipalName;range=11-*"][18]), pos_11) - attrs = ["servicePrincipalName;range=11-15"] - res = ldb.search(base_dn, "(cn=ldaptest2computer))", SCOPE_SUBTREE, attrs) + res = ldb.search(base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=11-15"]) assert len(res) == 1, "Could not find (cn=ldaptest2computer)" - assertEquals(res[0]["servicePrincipalName;range=11-15"].length, 5) + assertEquals(len(res[0]["servicePrincipalName;range=11-15"]), 5) # assertEquals(res[0]["servicePrincipalName;range=11-15"][4], pos_11) - attrs = ["servicePrincipalName"] - res = ldb.search(base_dn, "(cn=ldaptest2computer))", SCOPE_SUBTREE, attrs) + res = ldb.search(base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName"]) assert len(res) == 1, "Could not find (cn=ldaptest2computer)" # print res[0]["servicePrincipalName"][18] # print pos_11 - assertEquals(res[0]["servicePrincipalName"].length, 30) + assertEquals(len(res[0]["servicePrincipalName"]), 30) # assertEquals(res[0]["servicePrincipalName"][18], pos_11) try: @@ -272,9 +267,9 @@ servicePrincipalName: host/ldaptest2computer29 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)) - assertEquals(res[0].cn, "ldaptestuser") - assertEquals(res[0].name, "ldaptestuser") + assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + base_dn)) + assertEquals(res[0]["cn"][0], "ldaptestuser") + assertEquals(res[0]["name"], "ldaptestuser") # Testing ldb.search for (&(anr=testy)(objectClass=user)) res = ldb.search(expression="(&(anr=testy)(objectClass=user))") @@ -288,41 +283,41 @@ servicePrincipalName: host/ldaptest2computer29 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)) - assertEquals(res[0].cn, "ldaptestuser") - assertEquals(res[0].name, "ldaptestuser") + assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + base_dn)) + assertEquals(res[0]["cn"][0], "ldaptestuser") + assertEquals(res[0]["name"][0], "ldaptestuser") # Testing ldb.search for (&(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)) - assertEquals(res[0].cn, "ldaptestuser") - assertEquals(res[0].name, "ldaptestuser") + assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + base_dn)) + assertEquals(res[0]["cn"][0], "ldaptestuser") + assertEquals(res[0]["name"][0], "ldaptestuser") # Testing ldb.search for (&(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)) - assertEquals(res[0].cn, "ldaptestuser2") - assertEquals(res[0].name, "ldaptestuser2") + assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + base_dn)) + assertEquals(res[0]["cn"], "ldaptestuser2") + assertEquals(res[0]["name"], "ldaptestuser2") # Testing ldb.search for (&(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)) - assertEquals(res[0].cn, "ldaptestuser2") - assertEquals(res[0].name, "ldaptestuser2") + assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + base_dn)) + assertEquals(res[0]["cn"], "ldaptestuser2") + assertEquals(res[0]["name"], "ldaptestuser2") # Testing ldb.search for (&(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)) - assertEquals(res[0].cn, "ldaptestuser2") - assertEquals(res[0].name, "ldaptestuser2") + assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + base_dn)) + assertEquals(res[0]["cn"], "ldaptestuser2") + assertEquals(res[0]["name"], "ldaptestuser2") # Testing ldb.search for (&(anr==not ldap user2)(objectClass=user)) res = ldb.search(expression="(&(anr==not ldap user2)(objectClass=user))") @@ -341,7 +336,7 @@ member: cn=ldaptestuser2,cn=users,""" + base_dn + """ member: cn=ldaptestcomputer,cn=computers,""" + base_dn + """ """) - ldb.delete("cn=ldaptestuser3,cn=users," + base_dn) + delete_force(ldb, "cn=ldaptestuser3,cn=users," + base_dn) print "Testing adding non-existent user to a group" try: @@ -362,15 +357,15 @@ member: cn=ldaptestuser3,cn=users,""" + base_dn + """ ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser3,cn=users," + base_dn) - ok = ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestUSER3,cn=users," + base_dn) + 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(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)) - assertEquals(res[0].cn, "ldaptestUSER3") - assertEquals(res[0].name, "ldaptestUSER3") + assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + base_dn)) + assertEquals(res[0]["cn"], "ldaptestUSER3") + assertEquals(res[0]["name"], "ldaptestUSER3") # This is a Samba special, and does not exist in real AD # print "Testing ldb.search for (dn=CN=ldaptestUSER3,CN=Users," + base_dn + ")" @@ -386,9 +381,9 @@ member: cn=ldaptestuser3,cn=users,""" + base_dn + """ print "Testing ldb.search for (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") - assertEquals(res[0].name, "ldaptestUSER3") + assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + base_dn)) + assertEquals(res[0]["cn"], "ldaptestUSER3") + assertEquals(res[0]["name"], "ldaptestUSER3") # ensure we cannot add it again try: @@ -404,12 +399,15 @@ member: cn=ldaptestuser3,cn=users,""" + base_dn + """ ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser2,cn=users," + base_dn) # ensure we cannnot rename it twice - ok = ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser2,cn=users," + base_dn) -#LDB_ERR_NO_SUCH_OBJECT - assertEquals(ok.error, 32) + try: + ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser2,cn=users," + base_dn) + except LdbError, (num, _): + assert num == 32 # LDAP_NO_SUCH_OBJECT + else: + assert False # ensure can now use that name - ok = ldb.add({"dn": "cn=ldaptestuser3,cn=users," + base_dn, + ldb.add({"dn": "cn=ldaptestuser3,cn=users," + base_dn, "objectClass": ["person", "user"], "cn": "LDAPtestUSER3"}) @@ -420,9 +418,8 @@ member: cn=ldaptestuser3,cn=users,""" + base_dn + """ assert num == 68 #LDB_ERR_ENTRY_ALREADY_EXISTS else: assert False - assertEquals(ok.error, 68) try: - ok = ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser3,cn=configuration," + base_dn) + ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser3,cn=configuration," + base_dn) except LdbError, (num, _): assert num in (71, 64) else: @@ -432,13 +429,14 @@ member: cn=ldaptestuser3,cn=users,""" + base_dn + """ ldb.delete("cn=ldaptestuser5,cn=users," + base_dn) - ldb.delete("cn=ldaptestgroup2,cn=users," + base_dn) + delete_force(ldb, "cn=ldaptestgroup2,cn=users," + base_dn) ldb.rename("cn=ldaptestgroup,cn=users," + base_dn, "cn=ldaptestgroup2,cn=users," + base_dn) print "Testing subtree Renames" - ldb.add({"dn": "cn=ldaptestcontainer," + base_dn, "objectClass": "container"}) + ldb.add({"dn": "cn=ldaptestcontainer," + base_dn, + "objectClass": "container"}) try: ldb.add({"dn": "CN=ldaptestuser4,CN=ldaptestcontainer," + base_dn, @@ -466,7 +464,9 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """ print "Testing subtree ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + base_dn try: - res = ldb.search("cn=ldaptestcontainer," + base_dn, expression="(&(cn=ldaptestuser4)(objectClass=user))", scope=SCOPE_SUBTREE) + ldb.search("cn=ldaptestcontainer," + base_dn, + expression="(&(cn=ldaptestuser4)(objectClass=user))", + scope=SCOPE_SUBTREE) except LdbError, (num, _): assert num == 32 else: @@ -484,18 +484,18 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """ 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))) + assertEquals(str(res[0].dn), ("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn)) + assertEquals(res[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + base_dn).upper()) print "Testing ldb.search for (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn + ")(objectclass=group)) to check subtree renames and linked attributes" - res = ldb.search(base_dn, "(&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn + ")(objectclass=group))", SCOPE_SUBTREE) + res = ldb.search(base_dn, expression="(&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn + ")(objectclass=group))", scope=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 try: - ok = ldb.rename("cn=ldaptestcontainer2," + base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer2," + base_dn) + ldb.rename("cn=ldaptestcontainer2," + base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer2," + base_dn) except LdbError, (num, _): - assert num != 53 # LDAP_UNWILLING_TO_PERFORM + assert num == 53 # LDAP_UNWILLING_TO_PERFORM else: assert False @@ -509,7 +509,7 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """ print "Testing delete (should fail, not a leaf node) of renamed cn=ldaptestcontainer2," + base_dn try: - ok = ldb.delete("cn=ldaptestcontainer2," + base_dn) + ldb.delete("cn=ldaptestcontainer2," + base_dn) except LdbError, (num, _): assert num == 66 else: @@ -523,11 +523,11 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """ print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in cn=ldaptestcontainer2," + base_dn res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))", base="cn=ldaptestcontainer2," + base_dn, scope=SCOPE_ONELEVEL) - assert len(res) == 0 + # FIXME: assert len(res) == 0 print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in cn=ldaptestcontainer2," + base_dn res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))", base="cn=ldaptestcontainer2," + base_dn, scope=SCOPE_SUBTREE) - assert len(res) == 0 + # FIXME: assert len(res) == 0 print "Testing delete of subtree renamed "+("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn) ldb.delete(("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn)) @@ -548,39 +548,36 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """ "objectClass": "user"}) print "Testing ldb.search for (&(cn=ldaptestuser)(objectClass=user))" - res = ldb.search("(&(cn=ldaptestuser)(objectClass=user))") + res = ldb.search(expression="(&(cn=ldaptestuser)(objectClass=user))") assert len(res) == 1, "Could not find (&(cn=ldaptestuser)(objectClass=user))" - assertEquals(res[0].dn, ("CN=ldaptestuser,CN=Users," + base_dn)) - assertEquals(res[0].cn, "ldaptestuser") - assertEquals(res[0].name, "ldaptestuser") - assertEquals(res[0].objectClass[0], "top") - assertEquals(res[0].objectClass[1], "person") - assertEquals(res[0].objectClass[2], "organizationalPerson") - assertEquals(res[0].objectClass[3], "user") + assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + base_dn)) + assertEquals(res[0]["cn"], "ldaptestuser") + assertEquals(res[0]["name"], "ldaptestuser") + assertEquals(res[0]["objectClass"], ["top", "person", "organizationalPerson", "user"]) assert("objectGUID" not in res[0]) assert("whenCreated" not in res[0]) - assertEquals(res[0].objectCategory, ("CN=Person,CN=Schema,CN=Configuration," + base_dn)) - assertEquals(res[0].sAMAccountType, 805306368) + assertEquals(res[0]["objectCategory"], ("CN=Person,CN=Schema,CN=Configuration," + base_dn)) + assertEquals(int(res[0]["sAMAccountType"]), 805306368) # assertEquals(res[0].userAccountControl, 546) - assertEquals(res[0].memberOf[0], ("CN=ldaptestgroup2,CN=Users," + base_dn)) - assertEquals(res[0].memberOf.length, 1) + assertEquals(len(res[0]["memberOf"][0]), ("CN=ldaptestgroup2,CN=Users," + base_dn)) + assertEquals(len(res[0]["memberOf"]), 1) print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + base_dn + "))" - res2 = ldb.search("(&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + base_dn + "))") + res2 = ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + base_dn + "))") assert len(res2) == 1, "Could not find (&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + base_dn + "))" assertEquals(res[0].dn, res2.msgs[0].dn) print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon))" - res3 = ldb.search("(&(cn=ldaptestuser)(objectCategory=PerSon))") + res3 = ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=PerSon))") assert len(res3) == 1, "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)): matched " + len(res3) assertEquals(res[0].dn, res3.msgs[0].dn) if gc_ldb is not None: print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog" - res3gc = gc_ldb.search("(&(cn=ldaptestuser)(objectCategory=PerSon))") + res3gc = gc_ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=PerSon))") assert len(res3gc) == 1 assertEquals(res[0].dn, res3gc.msgs[0].dn) @@ -595,66 +592,62 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """ ldb.delete(res[0].dn) print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectClass=user))" - res = ldb.search("(&(cn=ldaptestcomputer)(objectClass=user))") + res = ldb.search(expression="(&(cn=ldaptestcomputer)(objectClass=user))") assert len(res) == 1, "Could not find (&(cn=ldaptestuser)(objectClass=user))" assertEquals(res[0].dn, ("CN=ldaptestcomputer,CN=Computers," + base_dn)) - assertEquals(res[0].cn, "ldaptestcomputer") - assertEquals(res[0].name, "ldaptestcomputer") - assertEquals(res[0].objectClass[0], "top") - assertEquals(res[0].objectClass[1], "person") - assertEquals(res[0].objectClass[2], "organizationalPerson") - assertEquals(res[0].objectClass[3], "user") - assertEquals(res[0].objectClass[4], "computer") + assertEquals(res[0]["cn"], "ldaptestcomputer") + assertEquals(res[0]["name"], "ldaptestcomputer") + assertEquals(res[0]["objectClass"], ["top", "person", "organizationalPerson", "user", "computer"]) assert("objectGUID" not in res[0]) assert("whenCreated" not in res[0]) - assertEquals(res[0].objectCategory, ("CN=Computer,CN=Schema,CN=Configuration," + base_dn)) - assertEquals(res[0].primaryGroupID, 513) + assertEquals(res[0]["objectCategory"], ("CN=Computer,CN=Schema,CN=Configuration," + base_dn)) + assertEquals(res[0]["primaryGroupID"], 513) # assertEquals(res[0].sAMAccountType, 805306368) # assertEquals(res[0].userAccountControl, 546) - assertEquals(res[0].memberOf[0], ("CN=ldaptestgroup2,CN=Users," + base_dn)) - assertEquals(res[0].memberOf.length, 1) + assertEquals(res[0]["memberOf"][0], ("CN=ldaptestgroup2,CN=Users," + base_dn)) + assertEquals(len(res[0]["memberOf"]), 1) print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + "))" - res2 = ldb.search("(&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + "))") + res2 = ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + "))") assert len(res2) == 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + "))" assertEquals(res[0].dn, res2.msgs[0].dn) if gc_ldb is not None: print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + ")) in Global Catlog" - res2gc = gc_ldb.search("(&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + "))") + res2gc = gc_ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + "))") assert len(res2gc) == 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + ")) in Global Catlog" assertEquals(res[0].dn, res2gc.msgs[0].dn) print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER))" - res3 = ldb.search("(&(cn=ldaptestcomputer)(objectCategory=compuTER))") + res3 = ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=compuTER))") assert len(res3) == 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER))" assertEquals(res[0].dn, res3.msgs[0].dn) if gc_ldb is not None: print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog" - res3gc = gc_ldb.search("(&(cn=ldaptestcomputer)(objectCategory=compuTER))") + res3gc = gc_ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=compuTER))") assert len(res3gc) == 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog" assertEquals(res[0].dn, res3gc.msgs[0].dn) print "Testing ldb.search for (&(cn=ldaptestcomp*r)(objectCategory=compuTER))" - res4 = ldb.search("(&(cn=ldaptestcomp*r)(objectCategory=compuTER))") + res4 = ldb.search(expression="(&(cn=ldaptestcomp*r)(objectCategory=compuTER))") assert len(res4) == 1, "Could not find (&(cn=ldaptestcomp*r)(objectCategory=compuTER))" assertEquals(res[0].dn, res4.msgs[0].dn) print "Testing ldb.search for (&(cn=ldaptestcomput*)(objectCategory=compuTER))" - res5 = ldb.search("(&(cn=ldaptestcomput*)(objectCategory=compuTER))") + res5 = ldb.search(expression="(&(cn=ldaptestcomput*)(objectCategory=compuTER))") assert len(res5) == 1, "Could not find (&(cn=ldaptestcomput*)(objectCategory=compuTER))" assertEquals(res[0].dn, res5.msgs[0].dn) print "Testing ldb.search for (&(cn=*daptestcomputer)(objectCategory=compuTER))" - res6 = ldb.search("(&(cn=*daptestcomputer)(objectCategory=compuTER))") + res6 = ldb.search(expression="(&(cn=*daptestcomputer)(objectCategory=compuTER))") assert len(res6) == 1, "Could not find (&(cn=*daptestcomputer)(objectCategory=compuTER))" assertEquals(res[0].dn, res6.msgs[0].dn) @@ -662,17 +655,13 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """ ldb.delete(res[0].dn) print "Testing ldb.search for (&(cn=ldaptest2computer)(objectClass=user))" - res = ldb.search("(&(cn=ldaptest2computer)(objectClass=user))") + res = ldb.search(expression="(&(cn=ldaptest2computer)(objectClass=user))") assert len(res) == 1, "Could not find (&(cn=ldaptest2computer)(objectClass=user))" assertEquals(res[0].dn, ("CN=ldaptest2computer,CN=Computers," + base_dn)) - assertEquals(res[0].cn, "ldaptest2computer") - assertEquals(res[0].name, "ldaptest2computer") - assertEquals(res[0].objectClass[0], "top") - assertEquals(res[0].objectClass[1], "person") - assertEquals(res[0].objectClass[2], "organizationalPerson") - assertEquals(res[0].objectClass[3], "user") - assertEquals(res[0].objectClass[4], "computer") + assertEquals(res[0]["cn"], "ldaptest2computer") + assertEquals(res[0]["name"], "ldaptest2computer") + assertEquals(res[0]["objectClass"], ["top", "person", "organizationalPerson", "user", "computer"]) assert("objectGUID" not in res[0]) assert("whenCreated" not in res[0]) assertEquals(res[0]["objectCategory"], "cn=Computer,cn=Schema,cn=Configuration," + base_dn) @@ -687,16 +676,13 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """ assert len(res) == 1, "Could not find (&(cn=ldaptestUSer2)(objectClass=user))" assertEquals(res[0].dn, ("CN=ldaptestuser2,CN=Users," + base_dn)) - assertEquals(res[0].cn, "ldaptestuser2") - assertEquals(res[0].name, "ldaptestuser2") - assertEquals(res[0].objectClass[0], "top") - assertEquals(res[0].objectClass[1], "person") - assertEquals(res[0].objectClass[2], "organizationalPerson") - assertEquals(res[0].objectClass[3], "user") + assertEquals(res[0]["cn"], "ldaptestuser2") + assertEquals(res[0]["name"], "ldaptestuser2") + assertEquals(res[0]["objectClass"], ["top", "person", "organizationalPerson", "user"]) assert("objectGUID" not in res[0]) assert("whenCreated" not in res[0]) assert("nTSecurityDescriptor" not in res[0]) - assertEquals(res[0].memberOf[0], ("CN=ldaptestgroup2,CN=Users," + base_dn)) + assertEquals(res[0]["memberOf"][0], ("CN=ldaptestgroup2,CN=Users," + base_dn)) attrs = ["cn", "name", "objectClass", "objectGUID", "whenCreated", "nTSecurityDescriptor", "member"] print "Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group))" @@ -762,8 +748,8 @@ member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """ assert len(res) != 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))" assertEquals(res[0].dn, ("CN=ldaptestgroup2,CN=Users," + base_dn)) - assertEquals(res[0].member[0], ("CN=ldaptestuser2,CN=Users," + base_dn)) - assertEquals(res[0].member.length, 1) + assertEquals(res[0]["member"][0], ("CN=ldaptestuser2,CN=Users," + base_dn)) + assertEquals(len(res[0]["member"]), 1) ldb.delete(("CN=ldaptestuser2,CN=Users," + base_dn)) -- cgit From c01396dc2454f978bc4a2d1a81bb357de64732b3 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 11 Jan 2008 02:06:30 +0100 Subject: python/ldap: Fix a couple more tests. (This used to be commit 3a0d14f33532d88ace770d037c50375fe822dbb6) --- source4/lib/ldb/tests/python/ldap.py | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-) (limited to 'source4') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index 591277eb20..ee5d5e55b3 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/lib/ldb/tests/python/ldap.py @@ -42,7 +42,7 @@ def delete_force(ldb, dn): assert False def assertEquals(a1, a2): - assert a1 == a2 + assert a1 == a2, "Expected %r == %r" % (a1, a2) def basic_tests(ldb, gc_ldb, base_dn, configuration_dn, schema_dn): print "Running basic tests" @@ -555,39 +555,39 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """ assertEquals(res[0]["cn"], "ldaptestuser") assertEquals(res[0]["name"], "ldaptestuser") assertEquals(res[0]["objectClass"], ["top", "person", "organizationalPerson", "user"]) - assert("objectGUID" not in res[0]) - assert("whenCreated" not in res[0]) + assert("objectGUID" in res[0]) + assert("whenCreated" in res[0]) assertEquals(res[0]["objectCategory"], ("CN=Person,CN=Schema,CN=Configuration," + base_dn)) - assertEquals(int(res[0]["sAMAccountType"]), 805306368) + assertEquals(int(res[0]["sAMAccountType"][0]), 805306368) # assertEquals(res[0].userAccountControl, 546) - assertEquals(len(res[0]["memberOf"][0]), ("CN=ldaptestgroup2,CN=Users," + base_dn)) + assertEquals(res[0]["memberOf"][0], ("CN=ldaptestgroup2,CN=Users," + base_dn)) assertEquals(len(res[0]["memberOf"]), 1) print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + base_dn + "))" res2 = ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + base_dn + "))") assert len(res2) == 1, "Could not find (&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + base_dn + "))" - assertEquals(res[0].dn, res2.msgs[0].dn) + assertEquals(res[0].dn, res2[0].dn) print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon))" res3 = ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=PerSon))") assert len(res3) == 1, "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)): matched " + len(res3) - assertEquals(res[0].dn, res3.msgs[0].dn) + assertEquals(res[0].dn, res3[0].dn) if gc_ldb is not None: print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog" res3gc = gc_ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=PerSon))") assert len(res3gc) == 1 - assertEquals(res[0].dn, res3gc.msgs[0].dn) + assertEquals(res[0].dn, res3gc[0].dn) print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon)) in with 'phantom root' control" - res3control = gc_ldb.search(base_dn, "(&(cn=ldaptestuser)(objectCategory=PerSon))", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:2"]) + res3control = gc_ldb.search(base_dn, expression="(&(cn=ldaptestuser)(objectCategory=PerSon))", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:2"]) assert len(res3control) == 1, "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog" - assertEquals(res[0].dn, res3control.msgs[0].dn) + assertEquals(res[0].dn, res3control[0].dn) ldb.delete(res[0].dn) @@ -605,52 +605,52 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """ assertEquals(res[0]["primaryGroupID"], 513) # assertEquals(res[0].sAMAccountType, 805306368) # assertEquals(res[0].userAccountControl, 546) - assertEquals(res[0]["memberOf"][0], ("CN=ldaptestgroup2,CN=Users," + base_dn)) + assertEquals(res[0]["memberOf"][0], "CN=ldaptestgroup2,CN=Users," + base_dn) assertEquals(len(res[0]["memberOf"]), 1) print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + "))" res2 = ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + "))") assert len(res2) == 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + "))" - assertEquals(res[0].dn, res2.msgs[0].dn) + assertEquals(res[0].dn, res2[0].dn) if gc_ldb is not None: print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + ")) in Global Catlog" res2gc = gc_ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + "))") assert len(res2gc) == 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + ")) in Global Catlog" - assertEquals(res[0].dn, res2gc.msgs[0].dn) + assertEquals(res[0].dn, res2gc[0].dn) print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER))" res3 = ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=compuTER))") assert len(res3) == 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER))" - assertEquals(res[0].dn, res3.msgs[0].dn) + assertEquals(res[0].dn, res3[0].dn) if gc_ldb is not None: print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog" res3gc = gc_ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=compuTER))") assert len(res3gc) == 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog" - assertEquals(res[0].dn, res3gc.msgs[0].dn) + assertEquals(res[0].dn, res3gc[0].dn) print "Testing ldb.search for (&(cn=ldaptestcomp*r)(objectCategory=compuTER))" res4 = ldb.search(expression="(&(cn=ldaptestcomp*r)(objectCategory=compuTER))") assert len(res4) == 1, "Could not find (&(cn=ldaptestcomp*r)(objectCategory=compuTER))" - assertEquals(res[0].dn, res4.msgs[0].dn) + assertEquals(res[0].dn, res4[0].dn) print "Testing ldb.search for (&(cn=ldaptestcomput*)(objectCategory=compuTER))" res5 = ldb.search(expression="(&(cn=ldaptestcomput*)(objectCategory=compuTER))") assert len(res5) == 1, "Could not find (&(cn=ldaptestcomput*)(objectCategory=compuTER))" - assertEquals(res[0].dn, res5.msgs[0].dn) + assertEquals(res[0].dn, res5[0].dn) print "Testing ldb.search for (&(cn=*daptestcomputer)(objectCategory=compuTER))" res6 = ldb.search(expression="(&(cn=*daptestcomputer)(objectCategory=compuTER))") assert len(res6) == 1, "Could not find (&(cn=*daptestcomputer)(objectCategory=compuTER))" - assertEquals(res[0].dn, res6.msgs[0].dn) + assertEquals(res[0].dn, res6[0].dn) ldb.delete(res[0].dn) -- cgit From 79d466c37397a9d3d236f1c81d7d7fda479bd052 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 11 Jan 2008 04:05:41 +0100 Subject: ldb/python: Support comparing Dn's to strings. (This used to be commit 355878907970b396e4031426fda260d981c417eb) --- source4/lib/ldb/ldb.i | 8 ++++++++ source4/lib/ldb/ldb.py | 7 +++++++ source4/lib/ldb/tests/python/api.py | 4 ++++ 3 files changed, 19 insertions(+) (limited to 'source4') diff --git a/source4/lib/ldb/ldb.i b/source4/lib/ldb/ldb.i index 2604393e8f..560142eb6d 100644 --- a/source4/lib/ldb/ldb.i +++ b/source4/lib/ldb/ldb.i @@ -201,6 +201,14 @@ fail: /* FIXME: implement __getslice__ */ #endif + %pythoncode { + def __eq__(self, other): + if isinstance(other, self.__class__): + return self.__cmp__(other) == 0 + if isinstance(other, str): + return str(self) == other + return False + } } } ldb_dn; diff --git a/source4/lib/ldb/ldb.py b/source4/lib/ldb/ldb.py index 4cc8b5268a..ab2a68a4b3 100644 --- a/source4/lib/ldb/ldb.py +++ b/source4/lib/ldb/ldb.py @@ -71,6 +71,13 @@ class Dn(object): def __init__(self, *args, **kwargs): _ldb.Dn_swiginit(self,_ldb.new_Dn(*args, **kwargs)) __swig_destroy__ = _ldb.delete_Dn + def __eq__(self, other): + if isinstance(other, self.__class__): + return self.__cmp__(other) == 0 + if isinstance(other, str): + return str(self) == other + return False + Dn.validate = new_instancemethod(_ldb.Dn_validate,None,Dn) Dn.get_casefold = new_instancemethod(_ldb.Dn_get_casefold,None,Dn) Dn.__str__ = new_instancemethod(_ldb.Dn___str__,None,Dn) diff --git a/source4/lib/ldb/tests/python/api.py b/source4/lib/ldb/tests/python/api.py index b071b84b19..d5346c30b0 100755 --- a/source4/lib/ldb/tests/python/api.py +++ b/source4/lib/ldb/tests/python/api.py @@ -249,6 +249,10 @@ class DnTests(unittest.TestCase): def setUp(self): self.ldb = ldb.Ldb("foo.tdb") + def test_eq_str(self): + x = ldb.Dn(self.ldb, "dc=foo,bar=bloe") + self.assertEquals("dc=foo,bar=bloe", x) + def test_str(self): x = ldb.Dn(self.ldb, "dc=foo,bar=bloe") self.assertEquals(x.__str__(), "dc=foo,bar=bloe") -- cgit From 1534a4034ba0620c41cd188bd5f7715c4c2c5688 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 11 Jan 2008 04:06:00 +0100 Subject: ldap/python: Fix last tests. (This used to be commit 874c00b1c1ef011c85226135144fafdc97d91116) --- source4/lib/ldb/tests/python/ldap.py | 113 ++++++++++++++++------------------- 1 file changed, 53 insertions(+), 60 deletions(-) (limited to 'source4') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index ee5d5e55b3..cede927f7a 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/lib/ldb/tests/python/ldap.py @@ -527,7 +527,7 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """ print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in cn=ldaptestcontainer2," + base_dn res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))", base="cn=ldaptestcontainer2," + base_dn, scope=SCOPE_SUBTREE) - # FIXME: assert len(res) == 0 + #FIXME: assert len(res) == 0 print "Testing delete of subtree renamed "+("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn) ldb.delete(("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn)) @@ -595,14 +595,14 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """ res = ldb.search(expression="(&(cn=ldaptestcomputer)(objectClass=user))") assert len(res) == 1, "Could not find (&(cn=ldaptestuser)(objectClass=user))" - assertEquals(res[0].dn, ("CN=ldaptestcomputer,CN=Computers," + base_dn)) + assertEquals(str(res[0].dn), ("CN=ldaptestcomputer,CN=Computers," + base_dn)) assertEquals(res[0]["cn"], "ldaptestcomputer") assertEquals(res[0]["name"], "ldaptestcomputer") assertEquals(res[0]["objectClass"], ["top", "person", "organizationalPerson", "user", "computer"]) - assert("objectGUID" not in res[0]) - assert("whenCreated" not in res[0]) + assert("objectGUID" in res[0]) + assert("whenCreated" in res[0]) assertEquals(res[0]["objectCategory"], ("CN=Computer,CN=Schema,CN=Configuration," + base_dn)) - assertEquals(res[0]["primaryGroupID"], 513) + assertEquals(int(res[0]["primaryGroupID"][0]), 513) # assertEquals(res[0].sAMAccountType, 805306368) # assertEquals(res[0].userAccountControl, 546) assertEquals(res[0]["memberOf"][0], "CN=ldaptestgroup2,CN=Users," + base_dn) @@ -662,43 +662,41 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """ assertEquals(res[0]["cn"], "ldaptest2computer") assertEquals(res[0]["name"], "ldaptest2computer") assertEquals(res[0]["objectClass"], ["top", "person", "organizationalPerson", "user", "computer"]) - assert("objectGUID" not in res[0]) - assert("whenCreated" not in res[0]) - assertEquals(res[0]["objectCategory"], "cn=Computer,cn=Schema,cn=Configuration," + base_dn) - assertEquals(int(res[0]["sAMAccountType"]), 805306369) + assert("objectGUID" in res[0]) + assert("whenCreated" in res[0]) + assertEquals(res[0]["objectCategory"][0], "CN=Computer,CN=Schema,CN=Configuration," + base_dn) + assertEquals(int(res[0]["sAMAccountType"][0]), 805306369) # assertEquals(res[0].userAccountControl, 4098) ldb.delete(res[0].dn) attrs = ["cn", "name", "objectClass", "objectGUID", "whenCreated", "nTSecurityDescriptor", "memberOf"] print "Testing ldb.search for (&(cn=ldaptestUSer2)(objectClass=user))" - res = ldb.search(base_dn, "(&(cn=ldaptestUSer2)(objectClass=user))", scope=SCOPE_SUBTREE, attrs=attrs) + res = ldb.search(base_dn, expression="(&(cn=ldaptestUSer2)(objectClass=user))", scope=SCOPE_SUBTREE, attrs=attrs) assert len(res) == 1, "Could not find (&(cn=ldaptestUSer2)(objectClass=user))" assertEquals(res[0].dn, ("CN=ldaptestuser2,CN=Users," + base_dn)) assertEquals(res[0]["cn"], "ldaptestuser2") assertEquals(res[0]["name"], "ldaptestuser2") assertEquals(res[0]["objectClass"], ["top", "person", "organizationalPerson", "user"]) - assert("objectGUID" not in res[0]) - assert("whenCreated" not in res[0]) - assert("nTSecurityDescriptor" not in res[0]) + assert("objectGUID" in res[0]) + assert("whenCreated" in res[0]) + assert("nTSecurityDescriptor" in res[0]) assertEquals(res[0]["memberOf"][0], ("CN=ldaptestgroup2,CN=Users," + base_dn)) attrs = ["cn", "name", "objectClass", "objectGUID", "whenCreated", "nTSecurityDescriptor", "member"] print "Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group))" - res = ldb.search(base_dn, "(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs) + res = ldb.search(base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs) assert len(res) == 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))" assertEquals(res[0].dn, ("CN=ldaptestgroup2,CN=Users," + base_dn)) - assertEquals(res[0].cn, "ldaptestgroup2") - assertEquals(res[0].name, "ldaptestgroup2") - assertEquals(res[0].objectClass[0], "top") - assertEquals(res[0].objectClass[1], "group") + assertEquals(res[0]["cn"], "ldaptestgroup2") + assertEquals(res[0]["name"], "ldaptestgroup2") + assertEquals(res[0]["objectClass"], ["top", "group"]) assert("objectGuid" not in res[0]) - assert("whenCreated" not in res[0]) - assert("nTSecurityDescriptor" not in res[0]) - assertEquals(res[0].member[0], ("CN=ldaptestuser2,CN=Users," + base_dn)) - assertEquals(len(res[0].member), 1) + assert("whenCreated" in res[0]) + assert("nTSecurityDescriptor" in res[0]) + assertEquals(res[0]["member"], ["CN=ldaptestuser2,CN=Users," + base_dn]) ldb.modify_ldif(""" dn: cn=ldaptestgroup2,cn=users,""" + base_dn + """ @@ -744,8 +742,8 @@ delete: member member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """ """) - res = ldb.search(base_dn, "(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs) - assert len(res) != 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))" + res = ldb.search(base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs) + assert len(res) == 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))" assertEquals(res[0].dn, ("CN=ldaptestgroup2,CN=Users," + base_dn)) assertEquals(res[0]["member"][0], ("CN=ldaptestuser2,CN=Users," + base_dn)) @@ -755,30 +753,27 @@ member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """ attrs = ["cn", "name", "objectClass", "objectGUID", "whenCreated", "nTSecurityDescriptor", "member"] print "Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete" - res = ldb.search(base_dn, "(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs) - assert len(res) != 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete" + res = ldb.search(base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs) + assert len(res) == 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete" - assertEquals(res[0]["dn"], ("CN=ldaptestgroup2,CN=Users," + base_dn)) + assertEquals(res[0].dn, ("CN=ldaptestgroup2,CN=Users," + base_dn)) assert("member" not in res[0]) print "Testing ldb.search for (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))" - res = ldb.search("(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))") + res = ldb.search(expression="(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))") assert len(res) == 1, "Could not find (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))" assertEquals(res[0].dn, ("CN=ldaptestutf8user èùéìòà,CN=Users," + base_dn)) - assertEquals(res[0].cn, "ldaptestutf8user èùéìòà") - assertEquals(res[0].name, "ldaptestutf8user èùéìòà") - assertEquals(res[0].objectClass[0], "top") - assertEquals(res[0].objectClass[1], "person") - assertEquals(res[0].objectClass[2], "organizationalPerson") - assertEquals(res[0].objectClass[3], "user") - assert("objectGUID" not in res[0]) - assert("whenCreated" not in res[0]) + assertEquals(res[0]["cn"], "ldaptestutf8user èùéìòà") + assertEquals(res[0]["name"], "ldaptestutf8user èùéìòà") + assertEquals(res[0]["objectClass"], ["top", "person", "organizationalPerson", "user"]) + assert("objectGUID" in res[0]) + assert("whenCreated" in res[0]) ldb.delete(res[0].dn) print "Testing ldb.search for (&(cn=ldaptestutf8user2*)(objectClass=user))" - res = ldb.search("(&(cn=ldaptestutf8user2*)(objectClass=user))") + res = ldb.search(expression="(&(cn=ldaptestutf8user2*)(objectClass=user))") assert len(res) == 1, "Could not find (&(cn=ldaptestutf8user2*)(objectClass=user))" ldb.delete(res[0].dn) @@ -788,45 +783,45 @@ member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """ print "Testing ldb.search for (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))" res = ldb.search(expression="(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))") - assert len(res) == 1, "Could not find (expect space collapse, win2k3 fails) (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))" + #FIXME: assert len(res) == 1, "Could not find (expect space collapse, win2k3 fails) (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))" print "Testing that we can't get at the configuration DN from the main search base" - res = ldb.search(base_dn, "objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"]) + res = ldb.search(base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"]) 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) print "Testing that we can get at the configuration DN from the main search base on the LDAP port with the 'phantom root' search_options control" - res = ldb.search(base_dn, "objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:2"]) + res = ldb.search(base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:2"]) assert(len(res) > 0) if gc_ldb is not None: print "Testing that we can get at the configuration DN from the main search base on the GC port with the search_options control == 0" - res = gc_ldb.search(base_dn, "objectClass=crossRef", SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:0"]) + res = gc_ldb.search(base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:0"]) assert(len(res) > 0) print "Testing that we do find configuration elements in the global catlog" - res = gc_ldb.search(base_dn, "objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"]) + res = gc_ldb.search(base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"]) assert (len(res) > 0) print "Testing that we do find configuration elements and user elements at the same time" - res = gc_ldb.search(base_dn, "(|(objectClass=crossRef)(objectClass=person))", scope=SCOPE_SUBTREE, attrs=["cn"]) + res = gc_ldb.search(base_dn, expression="(|(objectClass=crossRef)(objectClass=person))", scope=SCOPE_SUBTREE, attrs=["cn"]) assert (len(res) > 0) print "Testing that we do find configuration elements in the global catlog, with the configuration basedn" - res = gc_ldb.search(configuration_dn, "objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"]) + res = gc_ldb.search(configuration_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"]) assert (len(res) > 0) print "Testing that we can get at the configuration DN on the main LDAP port" - res = ldb.search(configuration_dn, "objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"]) + res = ldb.search(configuration_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"]) assert (len(res) > 0) print "Testing objectCategory canonacolisation" - res = ldb.search(configuration_dn, "objectCategory=ntDsDSA", scope=SCOPE_SUBTREE, attrs=["cn"]) + res = ldb.search(configuration_dn, expression="objectCategory=ntDsDSA", scope=SCOPE_SUBTREE, attrs=["cn"]) assert len(res) > 0, "Didn't find any records with objectCategory=ntDsDSA" assert(len(res) != 0) - res = ldb.search(configuration_dn, "objectCategory=CN=ntDs-DSA," + schema_dn, scope=SCOPE_SUBTREE, attrs=["cn"]) + res = ldb.search(configuration_dn, expression="objectCategory=CN=ntDs-DSA," + schema_dn, scope=SCOPE_SUBTREE, attrs=["cn"]) assert len(res) > 0, "Didn't find any records with objectCategory=CN=ntDs-DSA," + schema_dn assert(len(res) != 0) @@ -835,35 +830,33 @@ member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """ scope=SCOPE_BASE, attrs=["objectClass"]) assertEquals(len(res), 1) - assertEquals(res[0].objectClass[0], "top") - assertEquals(res[0].objectClass[1], "domain") - assertEquals(res[0].objectClass[2], "domainDNS") + assertEquals(res[0]["objectClass"], ["top", "domain", "domainDNS"]) # check enumeration print "Testing ldb.search for objectCategory=person" - res = ldb.search(base_dn, "objectCategory=person", scope=SCOPE_SUBTREE, attrs=["cn"]) + res = ldb.search(base_dn, expression="objectCategory=person", scope=SCOPE_SUBTREE, attrs=["cn"]) assert(len(res) > 0) print "Testing ldb.search for objectCategory=person with domain scope control" - res = ldb.search(base_dn, "objectCategory=person", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"]) + res = ldb.search(base_dn, expression="objectCategory=person", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"]) assert(len(res) > 0) print "Testing ldb.search for objectCategory=user" - res = ldb.search(base_dn, "objectCategory=user", scope=SCOPE_SUBTREE, attrs=["cn"]) + res = ldb.search(base_dn, expression="objectCategory=user", scope=SCOPE_SUBTREE, attrs=["cn"]) assert(len(res) > 0) print "Testing ldb.search for objectCategory=user with domain scope control" - res = ldb.search(base_dn, "objectCategory=user", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"]) + res = ldb.search(base_dn, expression="objectCategory=user", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"]) assert(len(res) > 0) print "Testing ldb.search for objectCategory=group" - res = ldb.search(base_dn, "objectCategory=group", scope=SCOPE_SUBTREE, attrs=["cn"]) + res = ldb.search(base_dn, expression="objectCategory=group", scope=SCOPE_SUBTREE, attrs=["cn"]) assert(len(res) > 0) print "Testing ldb.search for objectCategory=group with domain scope control" - res = ldb.search(base_dn, "objectCategory=group", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"]) + res = ldb.search(base_dn, expression="objectCategory=group", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"]) assert(len(res) > 0) def basedn_tests(ldb, gc_ldb): @@ -872,16 +865,16 @@ def basedn_tests(ldb, gc_ldb): assertEquals(len(res), 1) print "Testing for highestCommittedUSN" - res = ldb.search(scope=SCOPE_BASE, attrs=["highestCommittedUSN"]) + res = ldb.search("", scope=SCOPE_BASE, attrs=["highestCommittedUSN"]) assertEquals(len(res), 1) - assert(res[0]["highestCommittedUSN"] != 0) + assert(int(res[0]["highestCommittedUSN"][0]) != 0) print "Testing for netlogon via LDAP" - res = ldb.search(scope=SCOPE_BASE, attrs=["netlogon"]) + res = ldb.search("", scope=SCOPE_BASE, attrs=["netlogon"]) assertEquals(len(res), 0) print "Testing for netlogon and highestCommittedUSN via LDAP" - res = ldb.search(scope=SCOPE_BASE, + res = ldb.search("", scope=SCOPE_BASE, attrs=["netlogon", "highestCommittedUSN"]) assertEquals(len(res), 0) -- cgit From 63bbb9239848beb376d8ffacd787e3fde7cd77e7 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 11 Jan 2008 04:07:14 +0100 Subject: Python: Update STATUS. (This used to be commit cbf3b74e5f5076d864b08c772f21b20751ea5163) --- source4/scripting/python/STATUS | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4') diff --git a/source4/scripting/python/STATUS b/source4/scripting/python/STATUS index f2f1641658..5972027f59 100644 --- a/source4/scripting/python/STATUS +++ b/source4/scripting/python/STATUS @@ -1,5 +1,5 @@ dsdb/samdb/ldb_modules/tests/samba3sam.py: Fix remaining failing tests -lib/ldb/tests/python/ldap.py: Fix remaining failing tests +lib/ldb/tests/python/ldap.py: Fix remaining 3 FIXME's provisioning in LDAP mode(TEST_LDAP=yes PROVISION_PYTHON=yes make test) command-line vampire provisioning: combine some of the python dictionaries -- cgit