From ea851658411e3ff03a906f7ae6afc7e9319d6f90 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 21 Nov 2007 11:47:55 +0100 Subject: r26068: Import improved Python bindings for LDB, including tests. (This used to be commit fc3a8caef749ddac56a4f035dde8b6ceeaa95c48) --- source4/lib/ldb/tests/python/api.py | 353 ++++++++++++++++++++++++++++++++++++ 1 file changed, 353 insertions(+) create mode 100755 source4/lib/ldb/tests/python/api.py (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/api.py b/source4/lib/ldb/tests/python/api.py new file mode 100755 index 0000000000..b140bfc599 --- /dev/null +++ b/source4/lib/ldb/tests/python/api.py @@ -0,0 +1,353 @@ +#!/usr/bin/python +# Simple tests for the ldb python API +# Copyright (C) 2007 Jelmer Vernooij +import sys +import unittest +sys.path.append("swig") +sys.path.append("build/lib.linux-i686-2.4") + +import ldb + +class NoContextTests(unittest.TestCase): + def test_valid_attr_name(self): + self.assertTrue(ldb.valid_attr_name("foo")) + self.assertFalse(ldb.valid_attr_name("24foo")) + + def test_timestring(self): + self.assertEquals("19700101000000.0Z", ldb.timestring(0)) + self.assertEquals("20071119191012.0Z", ldb.timestring(1195499412)) + + def test_string_to_time(self): + self.assertEquals(0, ldb.string_to_time("19700101000000.0Z")) + self.assertEquals(1195499412, ldb.string_to_time("20071119191012.0Z")) + + +class SimpleLdb(unittest.TestCase): + def test_connect(self): + ldb.Ldb("foo.tdb") + + def test_connect_none(self): + ldb.Ldb() + + def test_connect_later(self): + x = ldb.Ldb() + x.connect("foo.tdb") + + def test_set_create_perms(self): + x = ldb.Ldb() + x.set_create_perms(0600) + + def test_set_modules_dir(self): + x = ldb.Ldb() + x.set_modules_dir("/tmp") + + def test_search(self): + l = ldb.Ldb("foo.tdb") + self.assertEquals(len(l.search()), 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) + + def test_opaque(self): + l = ldb.Ldb("foo.tdb") + l.set_opaque("my_opaque", l) + self.assertTrue(l.get_opaque("my_opaque") is not None) + self.assertEquals(None, l.get_opaque("unknown")) + + def test_search_scope_base(self): + l = ldb.Ldb("foo.tdb") + self.assertEquals(len(l.search(ldb.Dn(l, "dc=foo"), + ldb.SCOPE_ONELEVEL)), 0) + + def test_delete(self): + l = ldb.Ldb("foo.tdb") + self.assertRaises(ldb.LdbError, lambda: l.delete(ldb.Dn(l, "dc=foo"))) + + def test_contains(self): + l = ldb.Ldb("foo.tdb") + self.assertFalse(ldb.Dn(l, "dc=foo") in l) + l = ldb.Ldb("foo.tdb") + m = ldb.Message() + m.dn = ldb.Dn(l, "dc=foo") + m["b"] = ["a"] + l.add(m) + try: + self.assertTrue(ldb.Dn(l, "dc=foo") in l) + finally: + l.delete(m.dn) + + def test_get_config_basedn(self): + l = ldb.Ldb("foo.tdb") + self.assertEquals(None, l.get_config_basedn()) + + def test_get_root_basedn(self): + l = ldb.Ldb("foo.tdb") + self.assertEquals(None, l.get_root_basedn()) + + def test_get_schema_basedn(self): + l = ldb.Ldb("foo.tdb") + self.assertEquals(None, l.get_schema_basedn()) + + def test_get_default_basedn(self): + l = ldb.Ldb("foo.tdb") + self.assertEquals(None, l.get_default_basedn()) + + def test_add(self): + l = ldb.Ldb("foo.tdb") + m = ldb.Message() + m.dn = ldb.Dn(l, "dc=foo") + m["bla"] = "bla" + self.assertEquals(len(l.search()), 1) + l.add(m) + try: + self.assertEquals(len(l.search()), 2) + finally: + l.delete(ldb.Dn(l, "dc=foo")) + + def test_add_dict(self): + l = ldb.Ldb("foo.tdb") + m = {"dn": ldb.Dn(l, "dc=foo"), + "bla": "bla"} + self.assertEquals(len(l.search()), 1) + l.add(m) + try: + self.assertEquals(len(l.search()), 2) + finally: + l.delete(ldb.Dn(l, "dc=foo")) + + def test_rename(self): + l = ldb.Ldb("foo.tdb") + m = ldb.Message() + m.dn = ldb.Dn(l, "dc=foo") + m["bla"] = "bla" + self.assertEquals(len(l.search()), 1) + l.add(m) + try: + l.rename(ldb.Dn(l, "dc=foo"), ldb.Dn(l, "dc=bar")) + self.assertEquals(len(l.search()), 2) + finally: + l.delete(ldb.Dn(l, "dc=bar")) + + def test_modify_delete(self): + l = ldb.Ldb("foo.tdb") + m = ldb.Message() + m.dn = ldb.Dn(l, "dc=modify") + 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["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")) + + def test_modify_add(self): + l = ldb.Ldb("foo.tdb") + m = ldb.Message() + m.dn = ldb.Dn(l, "dc=modify") + m["bla"] = ["1234"] + l.add(m) + try: + m = ldb.Message() + m.dn = ldb.Dn(l, "dc=modify") + 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")) + + def test_modify_modify(self): + l = ldb.Ldb("foo.tdb") + m = ldb.Message() + m.dn = ldb.Dn(l, "dc=modify") + m["bla"] = ["1234", "456"] + l.add(m) + try: + m = ldb.Message() + m.dn = ldb.Dn(l, "dc=modify") + 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")) + + def test_transaction_commit(self): + l = ldb.Ldb("foo.tdb") + l.transaction_start() + m = ldb.Message(ldb.Dn(l, "dc=foo")) + m["foo"] = ["bar"] + l.add(m) + l.transaction_commit() + l.delete(m.dn) + + def test_transaction_cancel(self): + l = ldb.Ldb("foo.tdb") + l.transaction_start() + m = ldb.Message(ldb.Dn(l, "dc=foo")) + m["foo"] = ["bar"] + l.add(m) + l.transaction_cancel() + self.assertEquals(0, len(l.search(ldb.Dn(l, "dc=foo")))) + + def test_set_debug(self): + def my_report_fn(level, text): + pass + l = ldb.Ldb("foo.tdb") + l.set_debug(my_report_fn) + + +class DnTests(unittest.TestCase): + def setUp(self): + self.ldb = ldb.Ldb("foo.tdb") + + def test_str(self): + x = ldb.Dn(self.ldb, "dc=foo,bar=bloe") + self.assertEquals(x.__str__(), "dc=foo,bar=bloe") + + def test_get_casefold(self): + x = ldb.Dn(self.ldb, "dc=foo,bar=bloe") + self.assertEquals(x.get_casefold(), "DC=FOO,BAR=bloe") + + def test_validate(self): + x = ldb.Dn(self.ldb, "dc=foo,bar=bloe") + self.assertTrue(x.validate()) + + def test_parent(self): + x = ldb.Dn(self.ldb, "dc=foo,bar=bloe") + self.assertEquals("bar=bloe", x.parent().__str__()) + + def test_compare(self): + x = ldb.Dn(self.ldb, "dc=foo,bar=bloe") + y = ldb.Dn(self.ldb, "dc=foo,bar=bloe") + self.assertEquals(x, y) + z = ldb.Dn(self.ldb, "dc=foo,bar=blie") + self.assertNotEquals(z, y) + + def test_is_valid(self): + x = ldb.Dn(self.ldb, "dc=foo,dc=bloe") + self.assertTrue(x.is_valid()) + x = ldb.Dn(self.ldb, "") + # is_valid()'s return values appears to be a side effect of + # some other ldb functions. yuck. + # self.assertFalse(x.is_valid()) + + def test_is_special(self): + x = ldb.Dn(self.ldb, "dc=foo,bar=bloe") + self.assertFalse(x.is_special()) + x = ldb.Dn(self.ldb, "@FOOBAR") + self.assertTrue(x.is_special()) + + def test_check_special(self): + x = ldb.Dn(self.ldb, "dc=foo,bar=bloe") + self.assertFalse(x.check_special("FOOBAR")) + x = ldb.Dn(self.ldb, "@FOOBAR") + self.assertTrue(x.check_special("@FOOBAR")) + + def test_len(self): + x = ldb.Dn(self.ldb, "dc=foo,bar=bloe") + self.assertEquals(2, len(x)) + x = ldb.Dn(self.ldb, "dc=foo") + self.assertEquals(1, len(x)) + + def test_add_child(self): + x = ldb.Dn(self.ldb, "dc=foo,bar=bloe") + self.assertTrue(x.add_child(ldb.Dn(self.ldb, "bla=bloe"))) + self.assertEquals("bla=bloe,dc=foo,bar=bloe", x.__str__()) + + def test_add_base(self): + x = ldb.Dn(self.ldb, "dc=foo,bar=bloe") + self.assertTrue(x.add_base(ldb.Dn(self.ldb, "bla=bloe"))) + self.assertEquals("dc=foo,bar=bloe,bla=bloe", x.__str__()) + + def test_add(self): + x = ldb.Dn(self.ldb, "dc=foo") + y = ldb.Dn(self.ldb, "bar=bla") + self.assertEquals("dc=foo,bar=bla", str(y + x)) + + def test_parse_ldif(self): + msgs = self.ldb.parse_ldif("dn: foo=bar\n") + msg = msgs.next() + self.assertEquals("foo=bar", str(msg[1].dn)) + self.assertTrue(isinstance(msg[1], ldb.Message)) + + def test_parse_ldif_more(self): + msgs = self.ldb.parse_ldif("dn: foo=bar\n\n\ndn: bar=bar") + msg = msgs.next() + self.assertEquals("foo=bar", str(msg[1].dn)) + msg = msgs.next() + self.assertEquals("bar=bar", str(msg[1].dn)) + + def test_canonical_string(self): + x = ldb.Dn(self.ldb, "dc=foo,bar=bloe") + self.assertEquals("/bloe/foo", x.canonical_str()) + + def test_canonical_ex_string(self): + x = ldb.Dn(self.ldb, "dc=foo,bar=bloe") + self.assertEquals("/bloe\nfoo", x.canonical_ex_str()) + + +class LdbMsgTests(unittest.TestCase): + def setUp(self): + self.msg = ldb.Message() + + def test_init_dn(self): + self.msg = ldb.Message(ldb.Dn(ldb.Ldb(), "dc=foo")) + self.assertEquals("dc=foo", str(self.msg.dn)) + + def test_len(self): + self.assertEquals(0, len(self.msg)) + + def test_notpresent(self): + self.assertRaises(KeyError, lambda: self.msg["foo"]) + + def test_del(self): + del self.msg["foo"] + + def test_add_value(self): + self.assertEquals(0, len(self.msg)) + self.msg["foo"] = ["foo"] + self.assertEquals(1, len(self.msg)) + + def test_add_value_multiple(self): + self.assertEquals(0, len(self.msg)) + self.msg["foo"] = ["foo", "bla"] + self.assertEquals(1, len(self.msg)) + self.assertEquals(["foo", "bla"], list(self.msg["foo"])) + + def test_set_value(self): + self.msg["foo"] = ["fool"] + self.assertEquals(["fool"], list(self.msg["foo"])) + self.msg["foo"] = ["bar"] + self.assertEquals(["bar"], list(self.msg["foo"])) + + def test_keys(self): + self.msg["foo"] = ["bla"] + self.msg["bar"] = ["bla"] + self.assertEquals(["foo", "bar"], self.msg.keys()) + + def test_dn(self): + self.msg.dn = ldb.Dn(ldb.Ldb("foo.tdb"), "@BASEINFO") + self.assertEquals("@BASEINFO", self.msg.dn.__str__()) + + +class MessageElementTests(unittest.TestCase): + def test_cmp_element(self): + x = ldb.MessageElement(["foo"]) + y = ldb.MessageElement(["foo"]) + z = ldb.MessageElement(["bzr"]) + self.assertEquals(x, y) + self.assertNotEquals(x, z) + + def test_create_iterable(self): + x = ldb.MessageElement(["foo"]) + self.assertEquals(["foo"], list(x)) -- cgit From 07beaf09c95a06636cb029fcc2dbbeb7293879ba Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 17 Dec 2007 03:25:28 +0100 Subject: r26480: Add utility class for testing LDB code. (This used to be commit d7f0b12c9e43b93705f6b9fa6b5ab74fe68e80a0) --- source4/lib/ldb/tests/python/api.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/api.py b/source4/lib/ldb/tests/python/api.py index b140bfc599..3b4de044b0 100755 --- a/source4/lib/ldb/tests/python/api.py +++ b/source4/lib/ldb/tests/python/api.py @@ -1,8 +1,11 @@ #!/usr/bin/python -# Simple tests for the ldb python API +# Simple tests for the ldb python bindings. # Copyright (C) 2007 Jelmer Vernooij + import sys import unittest + +# Required for the standalone LDB build sys.path.append("swig") sys.path.append("build/lib.linux-i686-2.4") -- cgit From 6e2459211dbd59c8884049faa0d63c1712dbadfe Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 19 Dec 2007 23:27:34 +0100 Subject: r26537: Support ldb.add({'dn': 'dc=foo,bar=bla', ...}). (This used to be commit e91fe76d296973430f71502c9b614d0dfac4d83c) --- source4/lib/ldb/tests/python/api.py | 10 ++++++++++ 1 file changed, 10 insertions(+) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/api.py b/source4/lib/ldb/tests/python/api.py index 3b4de044b0..b6d6170ec2 100755 --- a/source4/lib/ldb/tests/python/api.py +++ b/source4/lib/ldb/tests/python/api.py @@ -119,6 +119,16 @@ class SimpleLdb(unittest.TestCase): finally: l.delete(ldb.Dn(l, "dc=foo")) + def test_add_dict_string_dn(self): + l = ldb.Ldb("foo.tdb") + m = {"dn": "dc=foo", "bla": "bla"} + self.assertEquals(len(l.search()), 1) + l.add(m) + try: + self.assertEquals(len(l.search()), 2) + finally: + l.delete(ldb.Dn(l, "dc=foo")) + def test_rename(self): l = ldb.Ldb("foo.tdb") m = ldb.Message() -- cgit From fb021305e4bc1175ae0d1960fbafc7eba29ef2f0 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 22 Dec 2007 14:28:45 -0600 Subject: r26567: Allow registering new ldb modules from python. (This used to be commit 485db76d8476fce399a9b6cb977cf55ea35ec189) --- source4/lib/ldb/tests/python/api.py | 8 ++++++++ 1 file changed, 8 insertions(+) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/api.py b/source4/lib/ldb/tests/python/api.py index b6d6170ec2..c280a3f3c4 100755 --- a/source4/lib/ldb/tests/python/api.py +++ b/source4/lib/ldb/tests/python/api.py @@ -364,3 +364,11 @@ class MessageElementTests(unittest.TestCase): def test_create_iterable(self): x = ldb.MessageElement(["foo"]) self.assertEquals(["foo"], list(x)) + +class ExampleModule: + name = "example" + +class ModuleTests(unittest.TestCase): + def test_register_module(self): + ldb.register_module(ExampleModule()) + -- cgit From aa0a06f13c44e0eca0b3f2f0c34f0f7995b87159 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 23 Dec 2007 19:19:41 -0600 Subject: r26570: - Trim size of the swig-generated Python bindings by removing a bunch of {}'s. - Start working on Python equivalents for various EJS tests. - Fix regression in argument order for reg_diff_apply() in EJS bindings. (This used to be commit c550c03372cb260b78f6a6c132e70571bc4cb852) --- source4/lib/ldb/tests/python/api.py | 17 + source4/lib/ldb/tests/python/ldap.py | 1355 ++++++++++++++++++++++++++++++++++ 2 files changed, 1372 insertions(+) create mode 100755 source4/lib/ldb/tests/python/ldap.py (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/api.py b/source4/lib/ldb/tests/python/api.py index c280a3f3c4..d9dfce8718 100755 --- a/source4/lib/ldb/tests/python/api.py +++ b/source4/lib/ldb/tests/python/api.py @@ -52,6 +52,10 @@ class SimpleLdb(unittest.TestCase): l = ldb.Ldb("foo.tdb") self.assertEquals(len(l.search(ldb.Dn(l, ""), ldb.SCOPE_SUBTREE, "(dc=*)", ["dc"])), 0) + def test_search_string_dn(self): + l = ldb.Ldb("foo.tdb") + self.assertEquals(len(l.search("", ldb.SCOPE_SUBTREE, "(dc=*)", ["dc"])), 0) + def test_opaque(self): l = ldb.Ldb("foo.tdb") l.set_opaque("my_opaque", l) @@ -142,6 +146,19 @@ class SimpleLdb(unittest.TestCase): finally: l.delete(ldb.Dn(l, "dc=bar")) + def test_rename_string_dns(self): + l = ldb.Ldb("foo.tdb") + m = ldb.Message() + m.dn = ldb.Dn(l, "dc=foo") + m["bla"] = "bla" + self.assertEquals(len(l.search()), 1) + l.add(m) + try: + l.rename("dc=foo", "dc=bar") + self.assertEquals(len(l.search()), 2) + finally: + l.delete(ldb.Dn(l, "dc=bar")) + def test_modify_delete(self): l = ldb.Ldb("foo.tdb") m = ldb.Message() diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py new file mode 100755 index 0000000000..519e228fca --- /dev/null +++ b/source4/lib/ldb/tests/python/ldap.py @@ -0,0 +1,1355 @@ +#!/usr/bin/python +# This is a port of the original in testprogs/ejs/ldap.js + +import sys + +if len(sys.argv) < 2: + print "Usage: %s " % sys.argv[0] + sys.exit(1) + +host = sys.argv[1] + +def assertEquals(a1, a2): + assert 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) + + print "Testing group add with invalid member" + ok = ldb.add({ + "dn": "cn=ldaptestgroup,cn=uSers," + base_dn, + "objectclass": "group", + "member": "cn=ldaptestuser,cn=useRs," + base_dn}) + + if (ok.error != 32) { # LDAP_NO_SUCH_OBJECT + print ok.errstr + assertEquals(ok.error, 32) + } + + print "Testing user add" + ok = ldb.add({ + "dn": "cn=ldaptestuser,cn=uSers," + base_dn, + "objectclass": ["user", "person"], + "cN": "LDAPtestUSER", + "givenname": "ldap", + "sn": "testy"}) + if (ok.error != 0) { + ok = ldb.delete("cn=ldaptestuser,cn=users," + base_dn) + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + ok = ldb.add({ + "dn": "cn=ldaptestuser,cn=uSers," + base_dn, + "objectclass": ["user", "person"], + "cN": "LDAPtestUSER", + "givenname": "ldap", + "sn": "testy"}) + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + } + + ok = ldb.add({ + "dn": "cn=ldaptestgroup,cn=uSers," + base_dn, + "objectclass": "group", + "member": "cn=ldaptestuser,cn=useRs," + base_dn}) + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + + ok = ldb.add({ + "dn": "cn=ldaptestcomputer,cn=computers," + base_dn, + "objectclass": "computer", + "cN": "LDAPtestCOMPUTER"}) + if (ok.error != 0) { + ok = ldb.delete("cn=ldaptestcomputer,cn=computers," + base_dn) + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + ok = ldb.add({ + "dn": "cn=ldaptestcomputer,cn=computers," + base_dn, + "objectClass": "computer", + "cn": "LDAPtestCOMPUTER"}) + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + } + + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + + ok = ldb.add({"dn": "cn=ldaptest2computer,cn=computers," + base_dn, + "objectClass": "computer", + "cn": "LDAPtest2COMPUTER", + "userAccountControl": "4096", + "displayname": "ldap testy"}) + if (ok.error != 0) { + ok = ldb.delete("cn=ldaptest2computer,cn=computers," + base_dn) + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + ok = ldb.add({ + "dn": "cn=ldaptest2computer,cn=computers," + base_dn, + "objectClass": "computer", + "cn": "LDAPtest2COMPUTER", + "userAccountControl": "4096", + "displayname": "ldap testy"}) + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + } + + print "Testing attribute or value exists behaviour" + ok = ldb.modify(" +dn: cn=ldaptest2computer,cn=computers," + base_dn + " +changetype: modify +replace: servicePrincipalName +servicePrincipalName: host/ldaptest2computer +servicePrincipalName: host/ldaptest2computer +servicePrincipalName: cifs/ldaptest2computer +") + +#LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS + if (ok.error != 20) { + print "Expected error LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS, got :" + ok.errstr + assertEquals(ok.error, 20) + } + + ok = ldb.modify(" +dn: cn=ldaptest2computer,cn=computers," + base_dn + " +changetype: modify +replace: servicePrincipalName +servicePrincipalName: host/ldaptest2computer +servicePrincipalName: cifs/ldaptest2computer +") + + if (ok.error != 0) { + print "Failed to replace servicePrincpalName:" + ok.errstr + assertEquals(ok.error, 20) + } + + ok = ldb.modify(" +dn: cn=ldaptest2computer,cn=computers," + base_dn + " +changetype: modify +add: servicePrincipalName +servicePrincipalName: host/ldaptest2computer +") + +#LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS + if (ok.error != 20) { + print "Expected error LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS, got :" + ok.errstr + assertEquals(ok.error, 20) + } + + print "Testing ranged results" + ok = ldb.modify(" +dn: cn=ldaptest2computer,cn=computers," + base_dn + " +changetype: modify +replace: servicePrincipalName +") + if (ok.error != 0) { + print "Failed to replace servicePrincpalName:" + ok.errstr + assertEquals(ok.error, 0) + } + + ok = ldb.modify(" +dn: cn=ldaptest2computer,cn=computers," + base_dn + " +changetype: modify +add: servicePrincipalName +servicePrincipalName: host/ldaptest2computer0 +servicePrincipalName: host/ldaptest2computer1 +servicePrincipalName: host/ldaptest2computer2 +servicePrincipalName: host/ldaptest2computer3 +servicePrincipalName: host/ldaptest2computer4 +servicePrincipalName: host/ldaptest2computer5 +servicePrincipalName: host/ldaptest2computer6 +servicePrincipalName: host/ldaptest2computer7 +servicePrincipalName: host/ldaptest2computer8 +servicePrincipalName: host/ldaptest2computer9 +servicePrincipalName: host/ldaptest2computer10 +servicePrincipalName: host/ldaptest2computer11 +servicePrincipalName: host/ldaptest2computer12 +servicePrincipalName: host/ldaptest2computer13 +servicePrincipalName: host/ldaptest2computer14 +servicePrincipalName: host/ldaptest2computer15 +servicePrincipalName: host/ldaptest2computer16 +servicePrincipalName: host/ldaptest2computer17 +servicePrincipalName: host/ldaptest2computer18 +servicePrincipalName: host/ldaptest2computer19 +servicePrincipalName: host/ldaptest2computer20 +servicePrincipalName: host/ldaptest2computer21 +servicePrincipalName: host/ldaptest2computer22 +servicePrincipalName: host/ldaptest2computer23 +servicePrincipalName: host/ldaptest2computer24 +servicePrincipalName: host/ldaptest2computer25 +servicePrincipalName: host/ldaptest2computer26 +servicePrincipalName: host/ldaptest2computer27 +servicePrincipalName: host/ldaptest2computer28 +servicePrincipalName: host/ldaptest2computer29 +") + + if (ok.error != 0) { + print "Failed to replace servicePrincpalName:" + ok.errstr + assertEquals(ok.error, 0) + } + + res = ldb.search(base_dn, expression="(cn=ldaptest2computer))", scope=ldb.SCOPE_SUBTREE, + attrs=["servicePrincipalName;range=0-*"]) + if (res.error != 0 || len(res) != 1) { + print "Could not find (cn=ldaptest2computer)" + assertEquals(res.error, 0) + assertEquals(len(res), 1) + } +# print res[0]["servicePrincipalName;range=0-*"].length + assertEquals(res[0]["servicePrincipalName;range=0-*"].length, 30) + + attrs = ["servicePrincipalName;range=0-19"] + res = ldb.search("(cn=ldaptest2computer))", base_dn, ldb.SCOPE_SUBTREE, attrs) + if (res.error != 0 || len(res) != 1) { + print "Could not find (cn=ldaptest2computer)" + assertEquals(res.error, 0) + assertEquals(len(res), 1) + } +# 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) + if (res.error != 0 || len(res) != 1) { + print "Could not find (cn=ldaptest2computer)" + assertEquals(res.error, 0) + assertEquals(len(res), 1) + } + assertEquals(res[0]["servicePrincipalName;range=0-*"].length, 30) + + attrs = ["servicePrincipalName;range=0-40"] + res = ldb.search("(cn=ldaptest2computer))", base_dn, ldb.SCOPE_SUBTREE, attrs) + if (res.error != 0 || len(res) != 1) { + print "Could not find (cn=ldaptest2computer)" + assertEquals(res.error, 0) + assertEquals(len(res), 1) + } + assertEquals(res[0]["servicePrincipalName;range=0-*"].length, 30) + + attrs = ["servicePrincipalName;range=30-40"] + res = ldb.search("(cn=ldaptest2computer))", base_dn, ldb.SCOPE_SUBTREE, attrs) + if (res.error != 0 || len(res) != 1) { + print "Could not find (cn=ldaptest2computer)" + assertEquals(res.error, 0) + assertEquals(len(res), 1) + } + assertEquals(res[0]["servicePrincipalName;range=30-*"].length, 0) + + attrs = ["servicePrincipalName;range=10-40"] + res = ldb.search("(cn=ldaptest2computer))", base_dn, ldb.SCOPE_SUBTREE, attrs) + if (res.error != 0 || len(res) != 1) { + print "Could not find (cn=ldaptest2computer)" + assertEquals(res.error, 0) + assertEquals(len(res), 1) + } + 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) + if (res.error != 0 || len(res) != 1) { + print "Could not find (cn=ldaptest2computer)" + assertEquals(res.error, 0) + assertEquals(len(res), 1) + } + assertEquals(res[0]["servicePrincipalName;range=11-*"].length, 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("(cn=ldaptest2computer))", base_dn, ldb.SCOPE_SUBTREE, attrs) + if (res.error != 0 || len(res) != 1) { + print "Could not find (cn=ldaptest2computer)" + assertEquals(res.error, 0) + assertEquals(len(res), 1) + } + 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) + if (res.error != 0 || len(res) != 1) { + print "Could not find (cn=ldaptest2computer)" + assertEquals(res.error, 0) + assertEquals(len(res), 1) + } +# print res[0]["servicePrincipalName"][18] +# print pos_11 + assertEquals(res[0]["servicePrincipalName"].length, 30) +# assertEquals(res[0]["servicePrincipalName"][18], pos_11) + + ok = ldb.add({ + "dn": "cn=ldaptestuser2,cn=useRs," + base_dn, + "objectClass": ["person", "user"], + "cn": "LDAPtestUSER2", + "givenname": "testy", + "sn": "ldap user2"}) + if (ok.error != 0) { + ok = ldb.delete("cn=ldaptestuser2,cn=users," + base_dn) + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + ok = ldb.add({ + "dn": "cn=ldaptestuser2,cn=useRs," + base_dn, + "objectClass": ["person", "user"], + "cn": "LDAPtestUSER2", + "givenname": "testy", + "sn": "ldap user2"}) + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + } + + + print "Testing Ambigious Name Resolution" +# Testing ldb.search for (&(anr=ldap testy)(objectClass=user)) + res = ldb.search("(&(anr=ldap testy)(objectClass=user))") + if (res.error != 0 || len(res) != 3) { + print "Could not find (&(anr=ldap testy)(objectClass=user))" + assertEquals(res.error, 0) + assertEquals(len(res), 3) + } + +# Testing ldb.search for (&(anr=testy ldap)(objectClass=user)) + res = ldb.search("(&(anr=testy ldap)(objectClass=user))") + if (res.error != 0 || len(res) != 2) { + print "Found only " + len(res) + " for (&(anr=testy ldap)(objectClass=user))" + assertEquals(res.error, 0) + assertEquals(len(res), 2) + } + +# Testing ldb.search for (&(anr=ldap)(objectClass=user)) + res = ldb.search("(&(anr=ldap)(objectClass=user))") + if (res.error != 0 || len(res) != 4) { + print "Found only " + len(res) + " for (&(anr=ldap)(objectClass=user))" + assertEquals(res.error, 0) + assertEquals(len(res), 4) + } + +# Testing ldb.search for (&(anr==ldap)(objectClass=user)) + res = ldb.search("(&(anr==ldap)(objectClass=user))") + if (res.error != 0 || len(res) != 1) { + print "Found only " + len(res) + " for (&(anr=ldap)(objectClass=user))" + print "Could not find (&(anr==ldap)(objectClass=user))" + assertEquals(res.error, 0) + assertEquals(len(res), 1) + } + + assertEquals(res[0].dn, ("CN=ldaptestuser,CN=Users," + base_dn)) + assertEquals(res[0].cn, "ldaptestuser") + assertEquals(res[0].name, "ldaptestuser") + +# Testing ldb.search for (&(anr=testy)(objectClass=user)) + res = ldb.search("(&(anr=testy)(objectClass=user))") + if (res.error != 0 || len(res) != 2) { + print "Found only " + len(res) + " for (&(anr=testy)(objectClass=user))" + assertEquals(res.error, 0) + assertEquals(len(res), 2) + } + +# Testing ldb.search for (&(anr=ldap testy)(objectClass=user)) + res = ldb.search("(&(anr=testy ldap)(objectClass=user))") + if (res.error != 0 || len(res) != 2) { + print "Found only " + len(res) + " for (&(anr=ldap testy)(objectClass=user))" + assertEquals(res.error, 0) + assertEquals(len(res), 2) + } + +# Testing ldb.search for (&(anr==ldap testy)(objectClass=user)) + res = ldb.search("(&(anr==testy ldap)(objectClass=user))") + if (res.error != 0 || len(res) != 1) { + print "Found only " + len(res) + " for (&(anr==ldap testy)(objectClass=user))" + assertEquals(res.error, 0) + assertEquals(len(res), 1) + } + + assertEquals(res[0].dn, ("CN=ldaptestuser,CN=Users," + base_dn)) + assertEquals(res[0].cn, "ldaptestuser") + assertEquals(res[0].name, "ldaptestuser") + +# Testing ldb.search for (&(anr==testy ldap)(objectClass=user)) + res = ldb.search("(&(anr==testy ldap)(objectClass=user))") + if (res.error != 0 || len(res) != 1) { + print "Could not find (&(anr==testy ldap)(objectClass=user))" + assertEquals(res.error, 0) + assertEquals(len(res), 1) + } + + assertEquals(res[0].dn, ("CN=ldaptestuser,CN=Users," + base_dn)) + assertEquals(res[0].cn, "ldaptestuser") + assertEquals(res[0].name, "ldaptestuser") + + # Testing ldb.search for (&(anr=testy ldap user)(objectClass=user)) + res = ldb.search("(&(anr=testy ldap user)(objectClass=user))") + if (res.error != 0 || len(res) != 1) { + print "Could not find (&(anr=testy ldap user)(objectClass=user))" + assertEquals(res.error, 0) + assertEquals(len(res), 1) + } + + assertEquals(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("(&(anr==testy ldap user2)(objectClass=user))") + if (res.error != 0 || len(res) != 1) { + print "Could not find (&(anr==testy ldap user2)(objectClass=user))" + assertEquals(res.error, 0) + assertEquals(len(res), 1) + } + + assertEquals(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("(&(anr==ldap user2)(objectClass=user))") + if (res.error != 0 || len(res) != 1) { + print "Could not find (&(anr==ldap user2)(objectClass=user))" + assertEquals(res.error, 0) + assertEquals(len(res), 1) + } + + assertEquals(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("(&(anr==not ldap user2)(objectClass=user))") + if (res.error != 0 || len(res) != 0) { + print "Must not find (&(anr==not ldap user2)(objectClass=user))" + assertEquals(res.error, 0) + assertEquals(len(res), 0) + } + + # Testing ldb.search for (&(anr=not ldap user2)(objectClass=user)) + res = ldb.search("(&(anr=not ldap user2)(objectClass=user))") + if (res.error != 0 || len(res) != 0) { + print "Must not find (&(anr=not ldap user2)(objectClass=user))" + assertEquals(res.error, 0) + assertEquals(len(res), 0) + } + + print "Testing Group Modifies" + ok = ldb.modify(" +dn: cn=ldaptestgroup,cn=users," + base_dn + " +changetype: modify +add: member +member: cn=ldaptestuser2,cn=users," + base_dn + " +member: cn=ldaptestcomputer,cn=computers," + base_dn + " +") + + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + + ok = ldb.delete("cn=ldaptestuser3,cn=users," + base_dn) + + print "Testing adding non-existent user to a group" + ok = ldb.modify(" +dn: cn=ldaptestgroup,cn=users," + base_dn + " +changetype: modify +add: member +member: cn=ldaptestuser3,cn=users," + base_dn + " +") + if (ok.error != 32) { # LDAP_NO_SUCH_OBJECT + print ok.errstr + assertEquals(ok.error, 32) + } + + print "Testing Renames" + + ok = ldb.rename("cn=ldaptestuser2,cn=users," + base_dn, "cn=ldaptestuser3,cn=users," + base_dn) + if (ok.error != 0) { + print "Could not rename cn=ldaptestuser2,cn=users," + base_dn + " into cn=ldaptestuser3,cn=users," + base_dn + ": " + ok.errstr + assertEquals(ok.error, 0) + } + + ok = ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser3,cn=users," + base_dn) + if (ok.error != 0) { + print "Could not rename cn=ldaptestuser3,cn=users," + base_dn + " onto itself: " + ok.errstr + assertEquals(ok.error, 0) + } + + ok = ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestUSER3,cn=users," + base_dn) + if (ok.error != 0) { + print "Could not rename cn=ldaptestuser3,cn=users," + base_dn + " into cn=ldaptestUSER3,cn=users," + base_dn + ": " + ok.errstr + assertEquals(ok.error, 0) + } + + print "Testing ldb.search for (&(cn=ldaptestuser3)(objectClass=user))" + res = ldb.search("(&(cn=ldaptestuser3)(objectClass=user))") + if (res.error != 0 || len(res) != 1) { + print "Could not find (&(cn=ldaptestuser3)(objectClass=user))" + assertEquals(res.error, 0) + assertEquals(len(res), 1) + } + + assertEquals(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 + ")" +# 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)) +# assertEquals(res[0].cn, "ldaptestUSER3") +# 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 + ")") + 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)) + assertEquals(res[0].cn, "ldaptestUSER3") + assertEquals(res[0].name, "ldaptestUSER3") + + # ensure we cannot add it again + ok = ldb.add({"dn": "cn=ldaptestuser3,cn=userS," + base_dn, + "objectClass": ["person", "user"], + "cn": "LDAPtestUSER3"}) +#LDB_ERR_ENTRY_ALREADY_EXISTS + if (ok.error != 68) { + print "expected error LDB_ERR_ENTRY_ALREADY_EXISTS, got: " + ok.errstr + assertEquals(ok.error, 68) + } + + # rename back + ok = ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser2,cn=users," + base_dn) + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + + # 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) + + # ensure can now use that name + ok = ldb.add({"dn": "cn=ldaptestuser3,cn=users," + base_dn, + "objectClass": ["person", "user"], + "cn": "LDAPtestUSER3"}) + + # ensure we now cannnot rename + ok = ldb.rename("cn=ldaptestuser2,cn=users," + base_dn, "cn=ldaptestuser3,cn=users," + base_dn) +#LDB_ERR_ENTRY_ALREADY_EXISTS + if (ok.error != 68) { + print "expected error LDB_ERR_ENTRY_ALREADY_EXISTS, got: " + ok.errstr + assertEquals(ok.error, 68) + } + assertEquals(ok.error, 68) + ok = ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser3,cn=configuration," + base_dn) + if (ok.error != 71 && ok.error != 64) { + print "expected error LDB_ERR_ENTRY_ALREADY_EXISTS or LDAP_NAMING_VIOLATION, got: " + ok.errstr + assertEquals(ok.error == 71 || ok.error, 64) + } + assertEquals(ok.error == 71 || ok.error, 64) + + ok = ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser5,cn=users," + base_dn) + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + + ok = ldb.delete("cn=ldaptestuser5,cn=users," + base_dn) + + ok = ldb.delete("cn=ldaptestgroup2,cn=users," + base_dn) + + ok = ldb.rename("cn=ldaptestgroup,cn=users," + base_dn, "cn=ldaptestgroup2,cn=users," + base_dn) + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + + print "Testing subtree Renames" + + ok = ldb.add({"dn": "cn=ldaptestcontainer," + base_dn, "objectClass": "container"}) + + ok = ldb.add({"dn": "CN=ldaptestuser4,CN=ldaptestcontainer," + base_dn, + "objectClass": ["person", "user"], + "cn": "LDAPtestUSER4"}) + if (ok.error != 0) { + ok = ldb.delete("cn=ldaptestuser4,cn=ldaptestcontainer," + base_dn) + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + ok = ldb.add({"dn": "CN=ldaptestuser4,CN=ldaptestcontainer," + base_dn, + "objectClass": ["person", "user"], + "cn": "LDAPtestUSER4"}) + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + } + + ok = ldb.modify(" +dn: cn=ldaptestgroup2,cn=users," + base_dn + " +changetype: modify +add: member +member: cn=ldaptestuser4,cn=ldaptestcontainer," + base_dn + " +") + if (ok.error != 0) { + print "Failure adding ldaptestuser4 to a group" + print ok.errstr + assertEquals(ok.error, 0) + } + + print "Testing ldb.rename of cn=ldaptestcontainer," + base_dn + " to cn=ldaptestcontainer2," + base_dn + ok = ldb.rename("CN=ldaptestcontainer," + base_dn, "CN=ldaptestcontainer2," + base_dn) + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + + print "Testing ldb.search for (&(cn=ldaptestuser4)(objectClass=user))" + res = ldb.search("(&(cn=ldaptestuser4)(objectClass=user))") + if (res.error != 0 || len(res) != 1) { + print "Could not find (&(cn=ldaptestuser4)(objectClass=user))" + assertEquals(res.error, 0) + assertEquals(len(res), 1) + } + + print "Testing subtree ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + base_dn + res = ldb.search("(&(cn=ldaptestuser4)(objectClass=user))", "cn=ldaptestcontainer," + base_dn, ldb.SCOPE_SUBTREE) + if (res.error != 32) { + print res.errstr + assertEquals(res.error, 32) + } + + print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + base_dn + res = ldb.search("(&(cn=ldaptestuser4)(objectClass=user))", "cn=ldaptestcontainer," + base_dn, ldb.SCOPE_ONELEVEL) + if (res.error != 32) { + print res.errstr + assertEquals(res.error, 32) + } + + 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) + if (res.error != 0 || len(res) != 1) { + print "Could not find (&(cn=ldaptestuser4)(objectClass=user)) under cn=ldaptestcontainer2," + base_dn + assertEquals(res.error, 0) + assertEquals(len(res), 1) + } + + 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) + if (res.error != 0 || len(res) != 1) { + print "Could not find (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn + ")(objectclass=group)), perhaps linked attributes are not conistant with subtree renames?" + assertEquals(res.error, 0) + assertEquals(len(res), 1) + } + + print "Testing ldb.rename (into itself) of cn=ldaptestcontainer2," + base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer2," + base_dn + ok = ldb.rename("cn=ldaptestcontainer2," + base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer2," + base_dn) + if (ok.error != 53) { # LDAP_UNWILLING_TO_PERFORM + print ok.errstr + assertEquals(ok.error, 53) + } + + print "Testing ldb.rename (into non-existent container) of cn=ldaptestcontainer2," + base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer3," + base_dn + ok = ldb.rename("cn=ldaptestcontainer2," + base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer3," + base_dn) + if (ok.error != 53 && ok.error != 80) { # LDAP_UNWILLING_TO_PERFORM or LDAP_OTHER + print ok.errstr + assertEquals(ok.error == 53 || ok.error, 80) + } + + print "Testing delete (should fail, not a leaf node) of renamed cn=ldaptestcontainer2," + base_dn + ok = ldb.delete("cn=ldaptestcontainer2," + base_dn) + if (ok.error != 66) { # LDB_ERR_NOT_ALLOWED_ON_NON_LEAF + print ok.errstr + assertEquals(ok.error, 66) + } + + 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) + if (res.error == 0 && res.count == 1) { + assertEquals(res.error == 0 && res.count, 1) + } + res = ldb.search("(cn=ldaptestuser40)", ("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn), ldb.SCOPE_BASE) + if (res.error == 0 && res.count == 0) { + assertEquals(res.error == 0 && res.count, 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) + if (res.error == 0 && res.count == 0) { + assertEquals(res.error == 0 && res.count, 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) + if (res.error == 0 && res.count == 0) { + assertEquals(res.error == 0 && res.count, 0) + } + + print "Testing delete of subtree renamed "+("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn) + ok = ldb.delete(("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn)) + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + print "Testing delete of renamed cn=ldaptestcontainer2," + base_dn + ok = ldb.delete("cn=ldaptestcontainer2," + base_dn) + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + + ok = ldb.add({"dn": "cn=ldaptestutf8user èùéìòà ,cn=users," + base_dn, "objectClass": "user"}) + if (ok.error != 0) { + ok = ldb.delete("cn=ldaptestutf8user èùéìòà ,cn=users," + base_dn) + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + ok = ldb.add({"dn": "cn=ldaptestutf8user èùéìòà ,cn=users," + base_dn, "objectClass": "user"}) + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + } + + ok = ldb.add({"dn": "cn=ldaptestutf8user2 èùéìòà ,cn=users," + base_dn, "objectClass": "user"}) + if (ok.error != 0) { + ok = ldb.delete("cn=ldaptestutf8user2 èùéìòà ,cn=users," + base_dn) + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + ok = ldb.add({"dn": "cn=ldaptestutf8user2 èùéìòà ,cn=users," + base_dn, + "objectClass": "user"}) + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + } + + print "Testing ldb.search for (&(cn=ldaptestuser)(objectClass=user))" + res = ldb.search("(&(cn=ldaptestuser)(objectClass=user))") + if (res.error != 0 || len(res) != 1) { + print "Could not find (&(cn=ldaptestuser)(objectClass=user))" + assertEquals(res.error, 0) + assertEquals(len(res), 1) + } + + 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") + assert(res[0].objectGUID != undefined) + assert(res[0].whenCreated != undefined) + assertEquals(res[0].objectCategory, ("CN=Person,CN=Schema,CN=Configuration," + base_dn)) + 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) + + 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 + "))") + if (res2.error != 0 || res2.msgs.length != 1) { + print "Could not find (&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + base_dn + "))" + assertEquals(res2.error, 0) + assertEquals(res2.msgs.length, 1) + } + + assertEquals(res[0].dn, res2.msgs[0].dn) + + print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon))" + res3 = ldb.search("(&(cn=ldaptestuser)(objectCategory=PerSon))") + if (res3.error != 0) { + print "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)): " + res3.errstr + assertEquals(res3.error, 0) + } else if (res3.msgs.length != 1) { + print "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)): matched " + res3.msgs.length + assertEquals(res3.msgs.length, 1) + } + + assertEquals(res[0].dn, res3.msgs[0].dn) + + if (gc_ldb != undefined) { + print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog" + res3gc = gc_ldb.search("(&(cn=ldaptestuser)(objectCategory=PerSon))") + if (res3gc.error != 0) { + print "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog: " + res3gc.errstr + assertEquals(res3gc.error, 0) + } else if (res3gc.msgs.length != 1) { + print "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog: matched " + res3gc.msgs.length + assertEquals(res3gc.msgs.length, 1) + } + + 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) + if (res3control.error != 0 || res3control.msgs.length != 1) { + print "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog" + assertEquals(res3control.error, 0) + assertEquals(res3control.msgs.length, 1) + } + + assertEquals(res[0].dn, res3control.msgs[0].dn) + + ok = ldb.delete(res[0].dn) + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + + print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectClass=user))" + res = ldb.search("(&(cn=ldaptestcomputer)(objectClass=user))") + if (res.error != 0 || len(res) != 1) { + print "Could not find (&(cn=ldaptestuser)(objectClass=user))" + assertEquals(res.error, 0) + assertEquals(len(res), 1) + } + + 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") + 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].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) + + 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 + "))") + if (res2.error != 0 || res2.msgs.length != 1) { + print "Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + "))" + assertEquals(res2.error, 0) + assertEquals(res2.msgs.length, 1) + } + + assertEquals(res[0].dn, res2.msgs[0].dn) + + if (gc_ldb != undefined) { + 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 + "))") + if (res2gc.error != 0 || res2gc.msgs.length != 1) { + print "Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + ")) in Global Catlog" + assertEquals(res2gc.error, 0) + assertEquals(res2gc.msgs.length, 1) + } + + assertEquals(res[0].dn, res2gc.msgs[0].dn) + } + + print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER))" + res3 = ldb.search("(&(cn=ldaptestcomputer)(objectCategory=compuTER))") + if (res3.error != 0 || res3.msgs.length != 1) { + print "Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER))" + assertEquals(res3.error, 0) + assertEquals(res3.msgs.length, 1) + } + + assertEquals(res[0].dn, res3.msgs[0].dn) + + if (gc_ldb != undefined) { + print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog" + res3gc = gc_ldb.search("(&(cn=ldaptestcomputer)(objectCategory=compuTER))") + if (res3gc.error != 0 || res3gc.msgs.length != 1) { + print "Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog" + assertEquals(res3gc.error, 0) + assertEquals(res3gc.msgs.length, 1) + } + + 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))") + if (res4.error != 0 || res4.msgs.length != 1) { + print "Could not find (&(cn=ldaptestcomp*r)(objectCategory=compuTER))" + assertEquals(res4.error, 0) + assertEquals(res4.msgs.length, 1) + } + + assertEquals(res[0].dn, res4.msgs[0].dn) + + print "Testing ldb.search for (&(cn=ldaptestcomput*)(objectCategory=compuTER))" + res5 = ldb.search("(&(cn=ldaptestcomput*)(objectCategory=compuTER))") + if (res5.error != 0 || res5.msgs.length != 1) { + print "Could not find (&(cn=ldaptestcomput*)(objectCategory=compuTER))" + assertEquals(res5.error, 0) + assertEquals(res5.msgs.length, 1) + } + + assertEquals(res[0].dn, res5.msgs[0].dn) + + print "Testing ldb.search for (&(cn=*daptestcomputer)(objectCategory=compuTER))" + res6 = ldb.search("(&(cn=*daptestcomputer)(objectCategory=compuTER))") + if (res6.error != 0 || res6.msgs.length != 1) { + print "Could not find (&(cn=*daptestcomputer)(objectCategory=compuTER))" + assertEquals(res6.error, 0) + assertEquals(res6.msgs.length, 1) + } + + assertEquals(res[0].dn, res6.msgs[0].dn) + + ok = ldb.delete(res[0].dn) + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + + print "Testing ldb.search for (&(cn=ldaptest2computer)(objectClass=user))" + res = ldb.search("(&(cn=ldaptest2computer)(objectClass=user))") + if (res.error != 0 || len(res) != 1) { + print "Could not find (&(cn=ldaptest2computer)(objectClass=user))" + assertEquals(res.error, 0) + assertEquals(len(res), 1) + } + + 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") + 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) +# assertEquals(res[0].userAccountControl, 4098) + + ok = ldb.delete(res[0].dn) + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + + 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) + if (res.error != 0 || len(res) != 1) { + print "Could not find (&(cn=ldaptestUSer2)(objectClass=user))" + assertEquals(res.error, 0) + assertEquals(len(res), 1) + } + + 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") + assert(res[0].objectGUID != undefined) + assert(res[0].whenCreated != undefined) + assert(res[0].nTSecurityDescriptor != undefined) + 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) + if (res.error != 0 || len(res) != 1) { + print "Could not find (&(cn=ldaptestgroup2)(objectClass=group))" + assertEquals(res.error, 0) + assertEquals(len(res), 1) + } + + 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") + assert(res[0].objectGUID != undefined) + assert(res[0].whenCreated != undefined) + assert(res[0].nTSecurityDescriptor != undefined) + assertEquals(res[0].member[0], ("CN=ldaptestuser2,CN=Users," + base_dn)) + assertEquals(res[0].member.length, 1) + + ok = ldb.modify(" +dn: cn=ldaptestgroup2,cn=users," + base_dn + " +changetype: modify +replace: member +member: CN=ldaptestuser2,CN=Users," + base_dn + " +member: CN=ldaptestutf8user èùéìòà,CN=Users," + base_dn + " +") + if (ok.error != 0) { + print "Failure testing replace of linked attributes" + print ok.errstr + assertEquals(ok.error, 0) + } + + print "Testing Linked attribute behaviours" + ok = ldb.modify(" +dn: cn=ldaptestgroup2,cn=users," + base_dn + " +changetype: modify +delete: member +") + if (ok.error != 0) { + print "Failure testing delete of linked attributes" + print ok.errstr + assertEquals(ok.error, 0) + } + + ok = ldb.modify(" +dn: cn=ldaptestgroup2,cn=users," + base_dn + " +changetype: modify +add: member +member: CN=ldaptestuser2,CN=Users," + base_dn + " +member: CN=ldaptestutf8user èùéìòà,CN=Users," + base_dn + " +") + if (ok.error != 0) { + print "Failure testing add of linked attributes" + print ok.errstr + assertEquals(ok.error, 0) + } + + ok = ldb.modify(" +dn: cn=ldaptestgroup2,cn=users," + base_dn + " +changetype: modify +replace: member +") + if (ok.error != 0) { + print "Failure testing replace of linked attributes" + print ok.errstr + assertEquals(ok.error, 0) + } + + ok = ldb.modify(" +dn: cn=ldaptestgroup2,cn=users," + base_dn + " +changetype: modify +add: member +member: CN=ldaptestuser2,CN=Users," + base_dn + " +member: CN=ldaptestutf8user èùéìòà,CN=Users," + base_dn + " +") + if (ok.error != 0) { + print "Failure testing add of linked attributes" + print ok.errstr + assertEquals(ok.error, 0) + } + + ok = ldb.modify(" +dn: cn=ldaptestgroup2,cn=users," + base_dn + " +changetype: modify +delete: member +member: CN=ldaptestutf8user èùéìòà,CN=Users," + base_dn + " +") + if (ok.error != 0) { + print "Failure testing replace of linked attributes" + print ok.errstr + assertEquals(ok.error, 0) + } + + res = ldb.search("(&(cn=ldaptestgroup2)(objectClass=group))", base_dn, ldb.SCOPE_SUBTREE, attrs) + if (res.error != 0 || len(res) != 1) { + print "Could not find (&(cn=ldaptestgroup2)(objectClass=group))" + assertEquals(res.error, 0) + assertEquals(len(res), 1) + } + + 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) + + ok = ldb.delete(("CN=ldaptestuser2,CN=Users," + base_dn)) + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + + 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) + if (res.error != 0 || len(res) != 1) { + print "Could not find (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete" + assertEquals(res.error, 0) + assertEquals(len(res), 1) + } + + assertEquals(res[0].dn, ("CN=ldaptestgroup2,CN=Users," + base_dn)) + assertEquals(res[0].member, undefined) + + print "Testing ldb.search for (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))" + res = ldb.search("(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))") + + if (res.error != 0 || len(res) != 1) { + print "Could not find (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))" + assertEquals(res.error, 0) + assertEquals(len(res), 1) + } + + 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(res[0].objectGUID != undefined) + assert(res[0].whenCreated != undefined) + + ok = ldb.delete(res[0].dn) + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + + print "Testing ldb.search for (&(cn=ldaptestutf8user2*)(objectClass=user))" + res = ldb.search("(&(cn=ldaptestutf8user2*)(objectClass=user))") + if (res.error != 0 || len(res) != 1) { + print "Could not find (&(cn=ldaptestutf8user2*)(objectClass=user))" + assertEquals(res.error, 0) + assertEquals(len(res), 1) + } + + ok = ldb.delete(res[0].dn) + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + + ok = ldb.delete(("CN=ldaptestgroup2,CN=Users," + base_dn)) + if (ok.error != 0) { + print ok.errstr + assertEquals(ok.error, 0) + } + + print "Testing ldb.search for (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))" + res = ldb.search("(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))") + + if (res.error != 0 || len(res) != 1) { + print "Could not find (expect space collapse, win2k3 fails) (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))" + } else { + assertEquals(res[0].dn, ("cn=ldaptestutf8user2 èùéìòà,cn=users," + base_dn)) + assertEquals(res[0].cn, "ldaptestutf8user2 èùéìòà") + } + + 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) + if (len(res) != 0) { + print "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) + assertEquals(res.error, 0) + assert(len(res) > 0) + + if (gc_ldb != undefined) { + 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) + 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) + if (len(res) == 0) { + print "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) + if (len(res) == 0) { + print "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) + assertEquals(len(res), 1) + + assertEquals(res[0].objectClass[0], "top") + assertEquals(res[0].objectClass[1], "domain") + assertEquals(res[0].objectClass[2], "domainDNS") + +# check enumeration + + 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) + assertEquals(len(res), 1) + + print "Testing for highestCommittedUSN" + attrs = ["highestCommittedUSN"] + res = ldb.search("", "", ldb.SCOPE_BASE, attrs) + assertEquals(res.error, 0) + 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) + 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) + assertEquals(len(res), 0) + +def find_basedn(ldb): + attrs = ["defaultNamingContext"] + res = ldb.search("", "", ldb.SCOPE_BASE, attrs) + assertEquals(res.error, 0) + assertEquals(len(res), 1) + return res[0].defaultNamingContext + +def find_configurationdn(ldb): + attrs = ["configurationNamingContext"] + res = ldb.search("", "", ldb.SCOPE_BASE, attrs) + assertEquals(res.error, 0) + assertEquals(len(res), 1) + return res[0].configurationNamingContext + +def find_schemadn(ldb): + res = ldb.search("", "", ldb.SCOPE_BASE, attrs=["schemaNamingContext"]) + assertEquals(res.error, 0) + assertEquals(len(res), 1) + return res[0].schemaNamingContext + +# use command line creds if available +ldb.credentials = options.get_credentials() +gc_ldb.credentials = options.get_credentials() + +ok = ldb.connect("ldap://" + host) +base_dn = find_basedn(ldb) + +configuration_dn = find_configurationdn(ldb) +schema_dn = find_schemadn(ldb) + +print "baseDN: %s\n" % base_dn + +ok = gc_ldb.connect("ldap://" + host + ":3268") +if (!ok) { + gc_ldb = undefined +} + +basic_tests(ldb, gc_ldb, base_dn, configuration_dn, schema_dn) +basedn_tests(ldb, gc_ldb) -- cgit From 18f9eaca071d031eb90185a1dec42d2f998d0b2c Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 27 Dec 2007 23:31:54 -0600 Subject: r26615: Fix Python syntax (This used to be commit cc15136c1e29f0a25847568f748cc1af52b7037b) --- source4/lib/ldb/tests/python/ldap.py | 1933 ++++++++++++++-------------------- 1 file changed, 772 insertions(+), 1161 deletions(-) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index 519e228fca..898a7336ad 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/lib/ldb/tests/python/ldap.py @@ -1,171 +1,142 @@ #!/usr/bin/python +# -*- coding: utf-8 -*- # This is a port of the original in testprogs/ejs/ldap.js +import getopt +import optparse import sys -if len(sys.argv) < 2: - print "Usage: %s " % sys.argv[0] +# Add path to the library for in-tree use +sys.path.append("scripting/python") +import samba.getopt as options + +from auth import system_session +from samba import Ldb + +parser = optparse.OptionParser("ldap [options] ") +parser.add_option_group(options.SambaOptions(parser)) +parser.add_option_group(options.VersionOptions(parser)) +# use command line creds if available +credopts = options.CredentialsOptions(parser) +parser.add_option_group(credopts) +creds = credopts.get_credentials() +opts, args = parser.parse_args() + +if len(args) < 1: + parser.print_usage() sys.exit(1) -host = sys.argv[1] +host = args[0] def assertEquals(a1, a2): assert a1 == a2 def basic_tests(ldb, gc_ldb, base_dn, configuration_dn, schema_dn): - print "Running basic tests" + print "Running basic tests" - ldb.delete("cn=ldaptestuser,cn=users," + base_dn) - ldb.delete("cn=ldaptestgroup,cn=users," + base_dn) + ldb.delete("cn=ldaptestuser,cn=users," + base_dn) + ldb.delete("cn=ldaptestgroup,cn=users," + base_dn) - print "Testing group add with invalid member" - ok = ldb.add({ + print "Testing group add with invalid member" + try: + ldb.add({ "dn": "cn=ldaptestgroup,cn=uSers," + base_dn, "objectclass": "group", "member": "cn=ldaptestuser,cn=useRs," + base_dn}) - - if (ok.error != 32) { # LDAP_NO_SUCH_OBJECT - print ok.errstr - assertEquals(ok.error, 32) - } - - print "Testing user add" - ok = ldb.add({ + except LdbError, (num, _): + assert error == 32 # LDAP_NO_SUCH_OBJECT + else: + assert False + + print "Testing user add" + try: + ldb.add({ "dn": "cn=ldaptestuser,cn=uSers," + base_dn, "objectclass": ["user", "person"], "cN": "LDAPtestUSER", "givenname": "ldap", "sn": "testy"}) - if (ok.error != 0) { - ok = ldb.delete("cn=ldaptestuser,cn=users," + base_dn) - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } - ok = ldb.add({ + except LdbError: + ldb.delete("cn=ldaptestuser,cn=users," + base_dn) + ldb.add({ "dn": "cn=ldaptestuser,cn=uSers," + base_dn, "objectclass": ["user", "person"], "cN": "LDAPtestUSER", "givenname": "ldap", "sn": "testy"}) - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } - } - ok = ldb.add({ + ldb.add({ "dn": "cn=ldaptestgroup,cn=uSers," + base_dn, "objectclass": "group", "member": "cn=ldaptestuser,cn=useRs," + base_dn}) - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } - ok = ldb.add({ + try: + ldb.add({ "dn": "cn=ldaptestcomputer,cn=computers," + base_dn, "objectclass": "computer", "cN": "LDAPtestCOMPUTER"}) - if (ok.error != 0) { - ok = ldb.delete("cn=ldaptestcomputer,cn=computers," + base_dn) - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } - ok = ldb.add({ + except LdbError: + ldb.delete("cn=ldaptestcomputer,cn=computers," + base_dn) + ldb.add({ "dn": "cn=ldaptestcomputer,cn=computers," + base_dn, "objectClass": "computer", "cn": "LDAPtestCOMPUTER"}) - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } - } - - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } - - ok = ldb.add({"dn": "cn=ldaptest2computer,cn=computers," + base_dn, + + try: + ldb.add({"dn": "cn=ldaptest2computer,cn=computers," + base_dn, "objectClass": "computer", "cn": "LDAPtest2COMPUTER", "userAccountControl": "4096", "displayname": "ldap testy"}) - if (ok.error != 0) { - ok = ldb.delete("cn=ldaptest2computer,cn=computers," + base_dn) - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } - ok = ldb.add({ + except LdbError: + ldb.delete("cn=ldaptest2computer,cn=computers," + base_dn) + ldb.add({ "dn": "cn=ldaptest2computer,cn=computers," + base_dn, "objectClass": "computer", "cn": "LDAPtest2COMPUTER", "userAccountControl": "4096", "displayname": "ldap testy"}) - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } - } - - print "Testing attribute or value exists behaviour" - ok = ldb.modify(" -dn: cn=ldaptest2computer,cn=computers," + base_dn + " + + print "Testing attribute or value exists behaviour" + try: + ldb.modify_ldif(""" +dn: cn=ldaptest2computer,cn=computers,""" + base_dn + """ changetype: modify replace: servicePrincipalName servicePrincipalName: host/ldaptest2computer servicePrincipalName: host/ldaptest2computer servicePrincipalName: cifs/ldaptest2computer -") - -#LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS - if (ok.error != 20) { - print "Expected error LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS, got :" + ok.errstr - assertEquals(ok.error, 20) - } +""") + except LdbError, (num, msg): + #LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS + assert num == 20, "Expected error LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS, got : %s" % msg - ok = ldb.modify(" -dn: cn=ldaptest2computer,cn=computers," + base_dn + " + ldb.modify_ldif(""" +dn: cn=ldaptest2computer,cn=computers,""" + base_dn + """ changetype: modify replace: servicePrincipalName servicePrincipalName: host/ldaptest2computer servicePrincipalName: cifs/ldaptest2computer -") - - if (ok.error != 0) { - print "Failed to replace servicePrincpalName:" + ok.errstr - assertEquals(ok.error, 20) - } - - ok = ldb.modify(" -dn: cn=ldaptest2computer,cn=computers," + base_dn + " +""") + try: + ldb.modify_ldif(""" +dn: cn=ldaptest2computer,cn=computers,""" + base_dn + """ changetype: modify add: servicePrincipalName servicePrincipalName: host/ldaptest2computer -") - -#LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS - if (ok.error != 20) { - print "Expected error LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS, got :" + ok.errstr - assertEquals(ok.error, 20) - } - - print "Testing ranged results" - ok = ldb.modify(" -dn: cn=ldaptest2computer,cn=computers," + base_dn + " +""") + except LdbError, (num, msg): + assert num == 20, "Expected error LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS, got :" + msg + + print "Testing ranged results" + ldb.modify_ldif(""" +dn: cn=ldaptest2computer,cn=computers,""" + base_dn + """ changetype: modify replace: servicePrincipalName -") - if (ok.error != 0) { - print "Failed to replace servicePrincpalName:" + ok.errstr - assertEquals(ok.error, 0) - } - - ok = ldb.modify(" -dn: cn=ldaptest2computer,cn=computers," + base_dn + " +""") + + ldb.modify_ldif(""" +dn: cn=ldaptest2computer,cn=computers,""" + base_dn + """ changetype: modify add: servicePrincipalName servicePrincipalName: host/ldaptest2computer0 @@ -198,1121 +169,766 @@ servicePrincipalName: host/ldaptest2computer26 servicePrincipalName: host/ldaptest2computer27 servicePrincipalName: host/ldaptest2computer28 servicePrincipalName: host/ldaptest2computer29 -") - - if (ok.error != 0) { - print "Failed to replace servicePrincpalName:" + ok.errstr - assertEquals(ok.error, 0) - } - - res = ldb.search(base_dn, expression="(cn=ldaptest2computer))", scope=ldb.SCOPE_SUBTREE, +""") + + res = ldb.search(base_dn, expression="(cn=ldaptest2computer))", scope=ldb.SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-*"]) - if (res.error != 0 || len(res) != 1) { - print "Could not find (cn=ldaptest2computer)" - assertEquals(res.error, 0) - assertEquals(len(res), 1) - } -# print res[0]["servicePrincipalName;range=0-*"].length - assertEquals(res[0]["servicePrincipalName;range=0-*"].length, 30) - - attrs = ["servicePrincipalName;range=0-19"] - res = ldb.search("(cn=ldaptest2computer))", base_dn, ldb.SCOPE_SUBTREE, attrs) - if (res.error != 0 || len(res) != 1) { - print "Could not find (cn=ldaptest2computer)" - assertEquals(res.error, 0) - assertEquals(len(res), 1) - } -# 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) - if (res.error != 0 || len(res) != 1) { - print "Could not find (cn=ldaptest2computer)" - assertEquals(res.error, 0) - assertEquals(len(res), 1) - } - assertEquals(res[0]["servicePrincipalName;range=0-*"].length, 30) - - attrs = ["servicePrincipalName;range=0-40"] - res = ldb.search("(cn=ldaptest2computer))", base_dn, ldb.SCOPE_SUBTREE, attrs) - if (res.error != 0 || len(res) != 1) { - print "Could not find (cn=ldaptest2computer)" - assertEquals(res.error, 0) - assertEquals(len(res), 1) - } - assertEquals(res[0]["servicePrincipalName;range=0-*"].length, 30) - - attrs = ["servicePrincipalName;range=30-40"] - res = ldb.search("(cn=ldaptest2computer))", base_dn, ldb.SCOPE_SUBTREE, attrs) - if (res.error != 0 || len(res) != 1) { - print "Could not find (cn=ldaptest2computer)" - assertEquals(res.error, 0) - assertEquals(len(res), 1) - } - assertEquals(res[0]["servicePrincipalName;range=30-*"].length, 0) - - attrs = ["servicePrincipalName;range=10-40"] - res = ldb.search("(cn=ldaptest2computer))", base_dn, ldb.SCOPE_SUBTREE, attrs) - if (res.error != 0 || len(res) != 1) { - print "Could not find (cn=ldaptest2computer)" - assertEquals(res.error, 0) - assertEquals(len(res), 1) - } - 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) - if (res.error != 0 || len(res) != 1) { - print "Could not find (cn=ldaptest2computer)" - assertEquals(res.error, 0) - assertEquals(len(res), 1) - } - assertEquals(res[0]["servicePrincipalName;range=11-*"].length, 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("(cn=ldaptest2computer))", base_dn, ldb.SCOPE_SUBTREE, attrs) - if (res.error != 0 || len(res) != 1) { - print "Could not find (cn=ldaptest2computer)" - assertEquals(res.error, 0) - assertEquals(len(res), 1) - } - 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) - if (res.error != 0 || len(res) != 1) { - print "Could not find (cn=ldaptest2computer)" - assertEquals(res.error, 0) - assertEquals(len(res), 1) - } -# print res[0]["servicePrincipalName"][18] -# print pos_11 - assertEquals(res[0]["servicePrincipalName"].length, 30) -# assertEquals(res[0]["servicePrincipalName"][18], pos_11) - - ok = ldb.add({ + assert len(res) == 1, "Could not find (cn=ldaptest2computer)" +# print res[0]["servicePrincipalName;range=0-*"].length + assertEquals(res[0]["servicePrincipalName;range=0-*"].length, 30) + + attrs = ["servicePrincipalName;range=0-19"] + res = ldb.search("(cn=ldaptest2computer))", base_dn, ldb.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) + 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) + 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) + 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) + 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) + assert len(res) == 1, "Could not find (cn=ldaptest2computer)" + assertEquals(res[0]["servicePrincipalName;range=11-*"].length, 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("(cn=ldaptest2computer))", base_dn, ldb.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) + assert len(res) == 1, "Could not find (cn=ldaptest2computer)" +# print res[0]["servicePrincipalName"][18] +# print pos_11 + assertEquals(res[0]["servicePrincipalName"].length, 30) +# assertEquals(res[0]["servicePrincipalName"][18], pos_11) + + try: + ldb.add({ "dn": "cn=ldaptestuser2,cn=useRs," + base_dn, "objectClass": ["person", "user"], "cn": "LDAPtestUSER2", "givenname": "testy", "sn": "ldap user2"}) - if (ok.error != 0) { - ok = ldb.delete("cn=ldaptestuser2,cn=users," + base_dn) - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } - ok = ldb.add({ + except LdbError: + ldb.delete("cn=ldaptestuser2,cn=users," + base_dn) + ldb.add({ "dn": "cn=ldaptestuser2,cn=useRs," + base_dn, "objectClass": ["person", "user"], "cn": "LDAPtestUSER2", "givenname": "testy", "sn": "ldap user2"}) - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } - } - - print "Testing Ambigious Name Resolution" + print "Testing Ambigious Name Resolution" # Testing ldb.search for (&(anr=ldap testy)(objectClass=user)) - res = ldb.search("(&(anr=ldap testy)(objectClass=user))") - if (res.error != 0 || len(res) != 3) { - print "Could not find (&(anr=ldap testy)(objectClass=user))" - assertEquals(res.error, 0) - assertEquals(len(res), 3) - } + res = ldb.search("(&(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))") - if (res.error != 0 || len(res) != 2) { - print "Found only " + len(res) + " for (&(anr=testy ldap)(objectClass=user))" - assertEquals(res.error, 0) - assertEquals(len(res), 2) - } + res = ldb.search("(&(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))") - if (res.error != 0 || len(res) != 4) { - print "Found only " + len(res) + " for (&(anr=ldap)(objectClass=user))" - assertEquals(res.error, 0) - assertEquals(len(res), 4) - } + res = ldb.search("(&(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))") - if (res.error != 0 || len(res) != 1) { - print "Found only " + len(res) + " for (&(anr=ldap)(objectClass=user))" - print "Could not find (&(anr==ldap)(objectClass=user))" - assertEquals(res.error, 0) - assertEquals(len(res), 1) - } - - assertEquals(res[0].dn, ("CN=ldaptestuser,CN=Users," + base_dn)) - assertEquals(res[0].cn, "ldaptestuser") - assertEquals(res[0].name, "ldaptestuser") + res = ldb.search("(&(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") # Testing ldb.search for (&(anr=testy)(objectClass=user)) - res = ldb.search("(&(anr=testy)(objectClass=user))") - if (res.error != 0 || len(res) != 2) { - print "Found only " + len(res) + " for (&(anr=testy)(objectClass=user))" - assertEquals(res.error, 0) - assertEquals(len(res), 2) - } + res = ldb.search("(&(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))") - if (res.error != 0 || len(res) != 2) { - print "Found only " + len(res) + " for (&(anr=ldap testy)(objectClass=user))" - assertEquals(res.error, 0) - assertEquals(len(res), 2) - } + res = ldb.search("(&(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))") - if (res.error != 0 || len(res) != 1) { - print "Found only " + len(res) + " for (&(anr==ldap testy)(objectClass=user))" - assertEquals(res.error, 0) - assertEquals(len(res), 1) - } + res = ldb.search("(&(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(res[0].dn, ("CN=ldaptestuser,CN=Users," + base_dn)) + assertEquals(res[0].cn, "ldaptestuser") + assertEquals(res[0].name, "ldaptestuser") # Testing ldb.search for (&(anr==testy ldap)(objectClass=user)) - res = ldb.search("(&(anr==testy ldap)(objectClass=user))") - if (res.error != 0 || len(res) != 1) { - print "Could not find (&(anr==testy ldap)(objectClass=user))" - assertEquals(res.error, 0) - assertEquals(len(res), 1) - } - - assertEquals(res[0].dn, ("CN=ldaptestuser,CN=Users," + base_dn)) - assertEquals(res[0].cn, "ldaptestuser") - assertEquals(res[0].name, "ldaptestuser") - - # Testing ldb.search for (&(anr=testy ldap user)(objectClass=user)) - res = ldb.search("(&(anr=testy ldap user)(objectClass=user))") - if (res.error != 0 || len(res) != 1) { - print "Could not find (&(anr=testy ldap user)(objectClass=user))" - assertEquals(res.error, 0) - assertEquals(len(res), 1) - } - - assertEquals(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("(&(anr==testy ldap user2)(objectClass=user))") - if (res.error != 0 || len(res) != 1) { - print "Could not find (&(anr==testy ldap user2)(objectClass=user))" - assertEquals(res.error, 0) - assertEquals(len(res), 1) - } - - assertEquals(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("(&(anr==ldap user2)(objectClass=user))") - if (res.error != 0 || len(res) != 1) { - print "Could not find (&(anr==ldap user2)(objectClass=user))" - assertEquals(res.error, 0) - assertEquals(len(res), 1) - } - - assertEquals(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("(&(anr==not ldap user2)(objectClass=user))") - if (res.error != 0 || len(res) != 0) { - print "Must not find (&(anr==not ldap user2)(objectClass=user))" - assertEquals(res.error, 0) - assertEquals(len(res), 0) - } - - # Testing ldb.search for (&(anr=not ldap user2)(objectClass=user)) - res = ldb.search("(&(anr=not ldap user2)(objectClass=user))") - if (res.error != 0 || len(res) != 0) { - print "Must not find (&(anr=not ldap user2)(objectClass=user))" - assertEquals(res.error, 0) - assertEquals(len(res), 0) - } - - print "Testing Group Modifies" - ok = ldb.modify(" -dn: cn=ldaptestgroup,cn=users," + base_dn + " + res = ldb.search("(&(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") + + # Testing ldb.search for (&(anr=testy ldap user)(objectClass=user)) + res = ldb.search("(&(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") + + # Testing ldb.search for (&(anr==testy ldap user2)(objectClass=user)) + res = ldb.search("(&(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") + + # Testing ldb.search for (&(anr==ldap user2)(objectClass=user)) + res = ldb.search("(&(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") + + # Testing ldb.search for (&(anr==not ldap user2)(objectClass=user)) + res = ldb.search("(&(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))") + assert len(res) == 0, "Must not find (&(anr=not ldap user2)(objectClass=user))" + + print "Testing Group Modifies" + ldb.modify_ldif(""" +dn: cn=ldaptestgroup,cn=users,""" + base_dn + """ changetype: modify add: member -member: cn=ldaptestuser2,cn=users," + base_dn + " -member: cn=ldaptestcomputer,cn=computers," + base_dn + " -") +member: cn=ldaptestuser2,cn=users,""" + base_dn + """ +member: cn=ldaptestcomputer,cn=computers,""" + base_dn + """ +""") - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } + ldb.delete("cn=ldaptestuser3,cn=users," + base_dn) - ok = ldb.delete("cn=ldaptestuser3,cn=users," + base_dn) - - print "Testing adding non-existent user to a group" - ok = ldb.modify(" -dn: cn=ldaptestgroup,cn=users," + base_dn + " + print "Testing adding non-existent user to a group" + try: + ldb.modify_ldif(""" +dn: cn=ldaptestgroup,cn=users,""" + base_dn + """ changetype: modify add: member -member: cn=ldaptestuser3,cn=users," + base_dn + " -") - if (ok.error != 32) { # LDAP_NO_SUCH_OBJECT - print ok.errstr - assertEquals(ok.error, 32) - } - - print "Testing Renames" - - ok = ldb.rename("cn=ldaptestuser2,cn=users," + base_dn, "cn=ldaptestuser3,cn=users," + base_dn) - if (ok.error != 0) { - print "Could not rename cn=ldaptestuser2,cn=users," + base_dn + " into cn=ldaptestuser3,cn=users," + base_dn + ": " + ok.errstr - assertEquals(ok.error, 0) - } - - ok = ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser3,cn=users," + base_dn) - if (ok.error != 0) { - print "Could not rename cn=ldaptestuser3,cn=users," + base_dn + " onto itself: " + ok.errstr - assertEquals(ok.error, 0) - } - - ok = ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestUSER3,cn=users," + base_dn) - if (ok.error != 0) { - print "Could not rename cn=ldaptestuser3,cn=users," + base_dn + " into cn=ldaptestUSER3,cn=users," + base_dn + ": " + ok.errstr - assertEquals(ok.error, 0) - } - - print "Testing ldb.search for (&(cn=ldaptestuser3)(objectClass=user))" - res = ldb.search("(&(cn=ldaptestuser3)(objectClass=user))") - if (res.error != 0 || len(res) != 1) { - print "Could not find (&(cn=ldaptestuser3)(objectClass=user))" - assertEquals(res.error, 0) - assertEquals(len(res), 1) - } - - assertEquals(res[0].dn, ("CN=ldaptestUSER3,CN=Users," + base_dn)) - assertEquals(res[0].cn, "ldaptestUSER3") - assertEquals(res[0].name, "ldaptestUSER3") +member: cn=ldaptestuser3,cn=users,""" + base_dn + """ +""") + except LdbError, (num, _): + assert num == 32 + else: + assert False + + print "Testing Renames" + + ldb.rename("cn=ldaptestuser2,cn=users," + base_dn, "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) + + print "Testing ldb.search for (&(cn=ldaptestuser3)(objectClass=user))" + res = ldb.search("(&(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") # This is a Samba special, and does not exist in real AD -# print "Testing ldb.search for (dn=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)) -# assertEquals(res[0].cn, "ldaptestUSER3") -# 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 + ")") - 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)) - assertEquals(res[0].cn, "ldaptestUSER3") - assertEquals(res[0].name, "ldaptestUSER3") - - # ensure we cannot add it again - ok = ldb.add({"dn": "cn=ldaptestuser3,cn=userS," + base_dn, +# print "Testing ldb.search for (dn=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)) +# assertEquals(res[0].cn, "ldaptestUSER3") +# 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 + ")") + 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") + + # ensure we cannot add it again + try: + ldb.add({"dn": "cn=ldaptestuser3,cn=userS," + base_dn, "objectClass": ["person", "user"], "cn": "LDAPtestUSER3"}) -#LDB_ERR_ENTRY_ALREADY_EXISTS - if (ok.error != 68) { - print "expected error LDB_ERR_ENTRY_ALREADY_EXISTS, got: " + ok.errstr - assertEquals(ok.error, 68) - } - - # rename back - ok = ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser2,cn=users," + base_dn) - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } - - # ensure we cannnot rename it twice - ok = ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser2,cn=users," + base_dn) + except LdbError, (num, _): + assert num == 68 #LDB_ERR_ENTRY_ALREADY_EXISTS + else: + assert False + + # rename back + 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) + assertEquals(ok.error, 32) - # ensure can now use that name - ok = ldb.add({"dn": "cn=ldaptestuser3,cn=users," + base_dn, + # ensure can now use that name + ok = ldb.add({"dn": "cn=ldaptestuser3,cn=users," + base_dn, "objectClass": ["person", "user"], "cn": "LDAPtestUSER3"}) - - # ensure we now cannnot rename - ok = ldb.rename("cn=ldaptestuser2,cn=users," + base_dn, "cn=ldaptestuser3,cn=users," + base_dn) -#LDB_ERR_ENTRY_ALREADY_EXISTS - if (ok.error != 68) { - print "expected error LDB_ERR_ENTRY_ALREADY_EXISTS, got: " + ok.errstr - assertEquals(ok.error, 68) - } - assertEquals(ok.error, 68) - ok = ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser3,cn=configuration," + base_dn) - if (ok.error != 71 && ok.error != 64) { - print "expected error LDB_ERR_ENTRY_ALREADY_EXISTS or LDAP_NAMING_VIOLATION, got: " + ok.errstr - assertEquals(ok.error == 71 || ok.error, 64) - } - assertEquals(ok.error == 71 || ok.error, 64) - - ok = ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser5,cn=users," + base_dn) - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } - - ok = ldb.delete("cn=ldaptestuser5,cn=users," + base_dn) - - ok = ldb.delete("cn=ldaptestgroup2,cn=users," + base_dn) - - ok = ldb.rename("cn=ldaptestgroup,cn=users," + base_dn, "cn=ldaptestgroup2,cn=users," + base_dn) - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } - - print "Testing subtree Renames" - - ok = ldb.add({"dn": "cn=ldaptestcontainer," + base_dn, "objectClass": "container"}) - - ok = ldb.add({"dn": "CN=ldaptestuser4,CN=ldaptestcontainer," + base_dn, - "objectClass": ["person", "user"], - "cn": "LDAPtestUSER4"}) - if (ok.error != 0) { - ok = ldb.delete("cn=ldaptestuser4,cn=ldaptestcontainer," + base_dn) - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } - ok = ldb.add({"dn": "CN=ldaptestuser4,CN=ldaptestcontainer," + base_dn, + + # ensure we now cannnot rename + try: + ldb.rename("cn=ldaptestuser2,cn=users," + base_dn, "cn=ldaptestuser3,cn=users," + base_dn) + except LdbError, (num, _): + 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) + except LdbError, (num, _): + assert num in (71, 64) + else: + assert False + + ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser5,cn=users," + base_dn) + + ldb.delete("cn=ldaptestuser5,cn=users," + base_dn) + + ldb.delete("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"}) + + try: + ldb.add({"dn": "CN=ldaptestuser4,CN=ldaptestcontainer," + base_dn, + "objectClass": ["person", "user"], + "cn": "LDAPtestUSER4"}) + except LdbError: + ldb.delete("cn=ldaptestuser4,cn=ldaptestcontainer," + base_dn) + ldb.add({"dn": "CN=ldaptestuser4,CN=ldaptestcontainer," + base_dn, "objectClass": ["person", "user"], "cn": "LDAPtestUSER4"}) - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } - } - - ok = ldb.modify(" -dn: cn=ldaptestgroup2,cn=users," + base_dn + " + + ldb.modify_ldif(""" +dn: cn=ldaptestgroup2,cn=users,""" + base_dn + """ changetype: modify add: member -member: cn=ldaptestuser4,cn=ldaptestcontainer," + base_dn + " -") - if (ok.error != 0) { - print "Failure adding ldaptestuser4 to a group" - print ok.errstr - assertEquals(ok.error, 0) - } - - print "Testing ldb.rename of cn=ldaptestcontainer," + base_dn + " to cn=ldaptestcontainer2," + base_dn - ok = ldb.rename("CN=ldaptestcontainer," + base_dn, "CN=ldaptestcontainer2," + base_dn) - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } - - print "Testing ldb.search for (&(cn=ldaptestuser4)(objectClass=user))" - res = ldb.search("(&(cn=ldaptestuser4)(objectClass=user))") - if (res.error != 0 || len(res) != 1) { - print "Could not find (&(cn=ldaptestuser4)(objectClass=user))" - assertEquals(res.error, 0) - assertEquals(len(res), 1) - } - - print "Testing subtree ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + base_dn - res = ldb.search("(&(cn=ldaptestuser4)(objectClass=user))", "cn=ldaptestcontainer," + base_dn, ldb.SCOPE_SUBTREE) - if (res.error != 32) { - print res.errstr - assertEquals(res.error, 32) - } - - print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + base_dn - res = ldb.search("(&(cn=ldaptestuser4)(objectClass=user))", "cn=ldaptestcontainer," + base_dn, ldb.SCOPE_ONELEVEL) - if (res.error != 32) { - print res.errstr - assertEquals(res.error, 32) - } - - 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) - if (res.error != 0 || len(res) != 1) { - print "Could not find (&(cn=ldaptestuser4)(objectClass=user)) under cn=ldaptestcontainer2," + base_dn - assertEquals(res.error, 0) - assertEquals(len(res), 1) - } - - 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) - if (res.error != 0 || len(res) != 1) { - print "Could not find (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn + ")(objectclass=group)), perhaps linked attributes are not conistant with subtree renames?" - assertEquals(res.error, 0) - assertEquals(len(res), 1) - } - - print "Testing ldb.rename (into itself) of cn=ldaptestcontainer2," + base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer2," + base_dn - ok = ldb.rename("cn=ldaptestcontainer2," + base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer2," + base_dn) - if (ok.error != 53) { # LDAP_UNWILLING_TO_PERFORM - print ok.errstr - assertEquals(ok.error, 53) - } - - print "Testing ldb.rename (into non-existent container) of cn=ldaptestcontainer2," + base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer3," + base_dn - ok = ldb.rename("cn=ldaptestcontainer2," + base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer3," + base_dn) - if (ok.error != 53 && ok.error != 80) { # LDAP_UNWILLING_TO_PERFORM or LDAP_OTHER - print ok.errstr - assertEquals(ok.error == 53 || ok.error, 80) - } - - print "Testing delete (should fail, not a leaf node) of renamed cn=ldaptestcontainer2," + base_dn - ok = ldb.delete("cn=ldaptestcontainer2," + base_dn) - if (ok.error != 66) { # LDB_ERR_NOT_ALLOWED_ON_NON_LEAF - print ok.errstr - assertEquals(ok.error, 66) - } - - 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) - if (res.error == 0 && res.count == 1) { - assertEquals(res.error == 0 && res.count, 1) - } - res = ldb.search("(cn=ldaptestuser40)", ("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn), ldb.SCOPE_BASE) - if (res.error == 0 && res.count == 0) { - assertEquals(res.error == 0 && res.count, 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) - if (res.error == 0 && res.count == 0) { - assertEquals(res.error == 0 && res.count, 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) - if (res.error == 0 && res.count == 0) { - assertEquals(res.error == 0 && res.count, 0) - } - - print "Testing delete of subtree renamed "+("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn) - ok = ldb.delete(("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn)) - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } - print "Testing delete of renamed cn=ldaptestcontainer2," + base_dn - ok = ldb.delete("cn=ldaptestcontainer2," + base_dn) - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } - - ok = ldb.add({"dn": "cn=ldaptestutf8user èùéìòà ,cn=users," + base_dn, "objectClass": "user"}) - if (ok.error != 0) { - ok = ldb.delete("cn=ldaptestutf8user èùéìòà ,cn=users," + base_dn) - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } - ok = ldb.add({"dn": "cn=ldaptestutf8user èùéìòà ,cn=users," + base_dn, "objectClass": "user"}) - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } - } - - ok = ldb.add({"dn": "cn=ldaptestutf8user2 èùéìòà ,cn=users," + base_dn, "objectClass": "user"}) - if (ok.error != 0) { - ok = ldb.delete("cn=ldaptestutf8user2 èùéìòà ,cn=users," + base_dn) - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } - ok = ldb.add({"dn": "cn=ldaptestutf8user2 èùéìòà ,cn=users," + base_dn, +member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """ +""") + + print "Testing ldb.rename of cn=ldaptestcontainer," + base_dn + " to cn=ldaptestcontainer2," + 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))") + 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) + except LdbError, (num, _): + assert num == 32 + else: + assert False + + 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) + 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) + 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) + 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) + except LdbError, (num, _): + assert num != 53 # LDAP_UNWILLING_TO_PERFORM + else: + assert False + + print "Testing ldb.rename (into non-existent container) of cn=ldaptestcontainer2," + base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer3," + base_dn + try: + ldb.rename("cn=ldaptestcontainer2," + base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer3," + base_dn) + except LdbError, (num, _): + assert num in (53, 80) + else: + assert False + + print "Testing delete (should fail, not a leaf node) of renamed cn=ldaptestcontainer2," + base_dn + try: + ok = ldb.delete("cn=ldaptestcontainer2," + base_dn) + except LdbError, (num, _): + assert num == 66 + else: + 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) + assert len(res) == 1 + res = ldb.search("(cn=ldaptestuser40)", ("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn), ldb.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) + 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) + assert len(res) == 0 + + print "Testing delete of subtree renamed "+("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn) + ldb.delete(("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn)) + print "Testing delete of renamed cn=ldaptestcontainer2," + base_dn + ldb.delete("cn=ldaptestcontainer2," + base_dn) + + try: + ldb.add({"dn": "cn=ldaptestutf8user èùéìòà ,cn=users," + base_dn, "objectClass": "user"}) + except LdbError, (num, _): + ldb.delete("cn=ldaptestutf8user èùéìòà ,cn=users," + base_dn) + ldb.add({"dn": "cn=ldaptestutf8user èùéìòà ,cn=users," + base_dn, "objectClass": "user"}) + + try: + ldb.add({"dn": "cn=ldaptestutf8user2 èùéìòà ,cn=users," + base_dn, "objectClass": "user"}) + except LdbError, (num, _): + ldb.delete("cn=ldaptestutf8user2 èùéìòà ,cn=users," + base_dn) + ldb.add({"dn": "cn=ldaptestutf8user2 èùéìòà ,cn=users," + base_dn, "objectClass": "user"}) - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } - } - - print "Testing ldb.search for (&(cn=ldaptestuser)(objectClass=user))" - res = ldb.search("(&(cn=ldaptestuser)(objectClass=user))") - if (res.error != 0 || len(res) != 1) { - print "Could not find (&(cn=ldaptestuser)(objectClass=user))" - assertEquals(res.error, 0) - assertEquals(len(res), 1) - } - - 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") - assert(res[0].objectGUID != undefined) - assert(res[0].whenCreated != undefined) - assertEquals(res[0].objectCategory, ("CN=Person,CN=Schema,CN=Configuration," + base_dn)) - 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) + + print "Testing ldb.search for (&(cn=ldaptestuser)(objectClass=user))" + res = ldb.search("(&(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") + assert(res[0].objectGUID != undefined) + assert(res[0].whenCreated != undefined) + assertEquals(res[0].objectCategory, ("CN=Person,CN=Schema,CN=Configuration," + base_dn)) + 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) - 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 + "))") - if (res2.error != 0 || res2.msgs.length != 1) { - print "Could not find (&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + base_dn + "))" - assertEquals(res2.error, 0) - assertEquals(res2.msgs.length, 1) - } - - assertEquals(res[0].dn, res2.msgs[0].dn) - - print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon))" - res3 = ldb.search("(&(cn=ldaptestuser)(objectCategory=PerSon))") - if (res3.error != 0) { - print "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)): " + res3.errstr - assertEquals(res3.error, 0) - } else if (res3.msgs.length != 1) { - print "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)): matched " + res3.msgs.length - assertEquals(res3.msgs.length, 1) - } - - assertEquals(res[0].dn, res3.msgs[0].dn) - - if (gc_ldb != undefined) { - print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog" - res3gc = gc_ldb.search("(&(cn=ldaptestuser)(objectCategory=PerSon))") - if (res3gc.error != 0) { - print "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog: " + res3gc.errstr - assertEquals(res3gc.error, 0) - } else if (res3gc.msgs.length != 1) { - print "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog: matched " + res3gc.msgs.length - assertEquals(res3gc.msgs.length, 1) - } - - 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) - if (res3control.error != 0 || res3control.msgs.length != 1) { - print "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog" - assertEquals(res3control.error, 0) - assertEquals(res3control.msgs.length, 1) - } - - assertEquals(res[0].dn, res3control.msgs[0].dn) - - ok = ldb.delete(res[0].dn) - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } - - print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectClass=user))" - res = ldb.search("(&(cn=ldaptestcomputer)(objectClass=user))") - if (res.error != 0 || len(res) != 1) { - print "Could not find (&(cn=ldaptestuser)(objectClass=user))" - assertEquals(res.error, 0) - assertEquals(len(res), 1) - } - - 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") - 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].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) - - 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 + "))") - if (res2.error != 0 || res2.msgs.length != 1) { - print "Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + "))" - assertEquals(res2.error, 0) - assertEquals(res2.msgs.length, 1) - } - - assertEquals(res[0].dn, res2.msgs[0].dn) - - if (gc_ldb != undefined) { - 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 + "))") - if (res2gc.error != 0 || res2gc.msgs.length != 1) { - print "Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + ")) in Global Catlog" - assertEquals(res2gc.error, 0) - assertEquals(res2gc.msgs.length, 1) - } - - assertEquals(res[0].dn, res2gc.msgs[0].dn) - } - - print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER))" - res3 = ldb.search("(&(cn=ldaptestcomputer)(objectCategory=compuTER))") - if (res3.error != 0 || res3.msgs.length != 1) { - print "Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER))" - assertEquals(res3.error, 0) - assertEquals(res3.msgs.length, 1) - } - - assertEquals(res[0].dn, res3.msgs[0].dn) - - if (gc_ldb != undefined) { - print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog" - res3gc = gc_ldb.search("(&(cn=ldaptestcomputer)(objectCategory=compuTER))") - if (res3gc.error != 0 || res3gc.msgs.length != 1) { - print "Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog" - assertEquals(res3gc.error, 0) - assertEquals(res3gc.msgs.length, 1) - } - - 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))") - if (res4.error != 0 || res4.msgs.length != 1) { - print "Could not find (&(cn=ldaptestcomp*r)(objectCategory=compuTER))" - assertEquals(res4.error, 0) - assertEquals(res4.msgs.length, 1) - } - - assertEquals(res[0].dn, res4.msgs[0].dn) - - print "Testing ldb.search for (&(cn=ldaptestcomput*)(objectCategory=compuTER))" - res5 = ldb.search("(&(cn=ldaptestcomput*)(objectCategory=compuTER))") - if (res5.error != 0 || res5.msgs.length != 1) { - print "Could not find (&(cn=ldaptestcomput*)(objectCategory=compuTER))" - assertEquals(res5.error, 0) - assertEquals(res5.msgs.length, 1) - } - - assertEquals(res[0].dn, res5.msgs[0].dn) - - print "Testing ldb.search for (&(cn=*daptestcomputer)(objectCategory=compuTER))" - res6 = ldb.search("(&(cn=*daptestcomputer)(objectCategory=compuTER))") - if (res6.error != 0 || res6.msgs.length != 1) { - print "Could not find (&(cn=*daptestcomputer)(objectCategory=compuTER))" - assertEquals(res6.error, 0) - assertEquals(res6.msgs.length, 1) - } - - assertEquals(res[0].dn, res6.msgs[0].dn) - - ok = ldb.delete(res[0].dn) - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } - - print "Testing ldb.search for (&(cn=ldaptest2computer)(objectClass=user))" - res = ldb.search("(&(cn=ldaptest2computer)(objectClass=user))") - if (res.error != 0 || len(res) != 1) { - print "Could not find (&(cn=ldaptest2computer)(objectClass=user))" - assertEquals(res.error, 0) - assertEquals(len(res), 1) - } - - 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") - 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) -# assertEquals(res[0].userAccountControl, 4098) - - ok = ldb.delete(res[0].dn) - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } + 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 + "))") + 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))") + 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))") + assert len(res3gc) == 1 + + 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) + assert len(res3control) == 1, "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog" + + assertEquals(res[0].dn, res3control.msgs[0].dn) + + ldb.delete(res[0].dn) + + print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectClass=user))" + res = ldb.search("(&(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") + 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].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) + + 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 + "))") + 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 + "))") + 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))") + 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))") + 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))") + 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))") + 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))") + assert len(res6) == 1, "Could not find (&(cn=*daptestcomputer)(objectCategory=compuTER))" + + assertEquals(res[0].dn, res6.msgs[0].dn) + + ldb.delete(res[0].dn) + + print "Testing ldb.search for (&(cn=ldaptest2computer)(objectClass=user))" + res = ldb.search("(&(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") + 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) +# 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) - if (res.error != 0 || len(res) != 1) { - print "Could not find (&(cn=ldaptestUSer2)(objectClass=user))" - assertEquals(res.error, 0) - assertEquals(len(res), 1) - } - - 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") - assert(res[0].objectGUID != undefined) - assert(res[0].whenCreated != undefined) - assert(res[0].nTSecurityDescriptor != undefined) - 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) - if (res.error != 0 || len(res) != 1) { - print "Could not find (&(cn=ldaptestgroup2)(objectClass=group))" - assertEquals(res.error, 0) - assertEquals(len(res), 1) - } - - 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") - assert(res[0].objectGUID != undefined) - assert(res[0].whenCreated != undefined) - assert(res[0].nTSecurityDescriptor != undefined) - assertEquals(res[0].member[0], ("CN=ldaptestuser2,CN=Users," + base_dn)) - assertEquals(res[0].member.length, 1) - - ok = ldb.modify(" -dn: cn=ldaptestgroup2,cn=users," + base_dn + " + print "Testing ldb.search for (&(cn=ldaptestUSer2)(objectClass=user))" + res = ldb.search(base_dn, "(&(cn=ldaptestUSer2)(objectClass=user))", ldb.SCOPE_SUBTREE, 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[0], "top") + 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) + 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) + 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") + assert(res[0].objectGUID != undefined) + assert(res[0].whenCreated != undefined) + assert(res[0].nTSecurityDescriptor != undefined) + assertEquals(res[0].member[0], ("CN=ldaptestuser2,CN=Users," + base_dn)) + assertEquals(res[0].member.length, 1) + + ldb.modify_ldif(""" +dn: cn=ldaptestgroup2,cn=users,""" + base_dn + """ changetype: modify replace: member -member: CN=ldaptestuser2,CN=Users," + base_dn + " -member: CN=ldaptestutf8user èùéìòà,CN=Users," + base_dn + " -") - if (ok.error != 0) { - print "Failure testing replace of linked attributes" - print ok.errstr - assertEquals(ok.error, 0) - } - - print "Testing Linked attribute behaviours" - ok = ldb.modify(" -dn: cn=ldaptestgroup2,cn=users," + base_dn + " +member: CN=ldaptestuser2,CN=Users,""" + base_dn + """ +member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """ +""") + + print "Testing Linked attribute behaviours" + ldb.modify_ldif(""" +dn: cn=ldaptestgroup2,cn=users,""" + base_dn + """ changetype: modify delete: member -") - if (ok.error != 0) { - print "Failure testing delete of linked attributes" - print ok.errstr - assertEquals(ok.error, 0) - } - - ok = ldb.modify(" -dn: cn=ldaptestgroup2,cn=users," + base_dn + " +""") + + ldb.modify_ldif(""" +dn: cn=ldaptestgroup2,cn=users,""" + base_dn + """ changetype: modify add: member -member: CN=ldaptestuser2,CN=Users," + base_dn + " -member: CN=ldaptestutf8user èùéìòà,CN=Users," + base_dn + " -") - if (ok.error != 0) { - print "Failure testing add of linked attributes" - print ok.errstr - assertEquals(ok.error, 0) - } - - ok = ldb.modify(" -dn: cn=ldaptestgroup2,cn=users," + base_dn + " +member: CN=ldaptestuser2,CN=Users,""" + base_dn + """ +member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """ +""") + + ldb.modify_ldif(""" +dn: cn=ldaptestgroup2,cn=users,""" + base_dn + """ changetype: modify replace: member -") - if (ok.error != 0) { - print "Failure testing replace of linked attributes" - print ok.errstr - assertEquals(ok.error, 0) - } - - ok = ldb.modify(" -dn: cn=ldaptestgroup2,cn=users," + base_dn + " +""") + + ldb.modify_ldif(""" +dn: cn=ldaptestgroup2,cn=users,""" + base_dn + """ changetype: modify add: member -member: CN=ldaptestuser2,CN=Users," + base_dn + " -member: CN=ldaptestutf8user èùéìòà,CN=Users," + base_dn + " -") - if (ok.error != 0) { - print "Failure testing add of linked attributes" - print ok.errstr - assertEquals(ok.error, 0) - } - - ok = ldb.modify(" -dn: cn=ldaptestgroup2,cn=users," + base_dn + " +member: CN=ldaptestuser2,CN=Users,""" + base_dn + """ +member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """ +""") + + ldb.modify_ldif(""" +dn: cn=ldaptestgroup2,cn=users,""" + base_dn + """ changetype: modify delete: member -member: CN=ldaptestutf8user èùéìòà,CN=Users," + base_dn + " -") - if (ok.error != 0) { - print "Failure testing replace of linked attributes" - print ok.errstr - assertEquals(ok.error, 0) - } - - res = ldb.search("(&(cn=ldaptestgroup2)(objectClass=group))", base_dn, ldb.SCOPE_SUBTREE, attrs) - if (res.error != 0 || len(res) != 1) { - print "Could not find (&(cn=ldaptestgroup2)(objectClass=group))" - assertEquals(res.error, 0) - assertEquals(len(res), 1) - } - - 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) - - ok = ldb.delete(("CN=ldaptestuser2,CN=Users," + base_dn)) - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } - - 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) - if (res.error != 0 || len(res) != 1) { - print "Could not find (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete" - assertEquals(res.error, 0) - assertEquals(len(res), 1) - } - - assertEquals(res[0].dn, ("CN=ldaptestgroup2,CN=Users," + base_dn)) - assertEquals(res[0].member, undefined) - - print "Testing ldb.search for (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))" - res = ldb.search("(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))") - - if (res.error != 0 || len(res) != 1) { - print "Could not find (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))" - assertEquals(res.error, 0) - assertEquals(len(res), 1) - } - - 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(res[0].objectGUID != undefined) - assert(res[0].whenCreated != undefined) - - ok = ldb.delete(res[0].dn) - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } - - print "Testing ldb.search for (&(cn=ldaptestutf8user2*)(objectClass=user))" - res = ldb.search("(&(cn=ldaptestutf8user2*)(objectClass=user))") - if (res.error != 0 || len(res) != 1) { - print "Could not find (&(cn=ldaptestutf8user2*)(objectClass=user))" - assertEquals(res.error, 0) - assertEquals(len(res), 1) - } - - ok = ldb.delete(res[0].dn) - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } - - ok = ldb.delete(("CN=ldaptestgroup2,CN=Users," + base_dn)) - if (ok.error != 0) { - print ok.errstr - assertEquals(ok.error, 0) - } - - print "Testing ldb.search for (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))" - res = ldb.search("(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))") - - if (res.error != 0 || len(res) != 1) { - print "Could not find (expect space collapse, win2k3 fails) (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))" - } else { - assertEquals(res[0].dn, ("cn=ldaptestutf8user2 èùéìòà,cn=users," + base_dn)) - assertEquals(res[0].cn, "ldaptestutf8user2 èùéìòà") - } - - 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) - if (len(res) != 0) { - print "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) - assertEquals(res.error, 0) - assert(len(res) > 0) - - if (gc_ldb != undefined) { - 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) - 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) - if (len(res) == 0) { - print "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) - if (len(res) == 0) { - print "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) - assertEquals(len(res), 1) - - assertEquals(res[0].objectClass[0], "top") - assertEquals(res[0].objectClass[1], "domain") - assertEquals(res[0].objectClass[2], "domainDNS") +member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """ +""") + + res = ldb.search("(&(cn=ldaptestgroup2)(objectClass=group))", base_dn, ldb.SCOPE_SUBTREE, 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)) + assertEquals(res[0].member.length, 1) + + ldb.delete(("CN=ldaptestuser2,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) + 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) + + print "Testing ldb.search for (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))" + res = ldb.search("(&(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(res[0].objectGUID != undefined) + assert(res[0].whenCreated != undefined) + + ldb.delete(res[0].dn) + + print "Testing ldb.search for (&(cn=ldaptestutf8user2*)(objectClass=user))" + res = ldb.search("(&(cn=ldaptestutf8user2*)(objectClass=user))") + assert len(res) == 1, "Could not find (&(cn=ldaptestutf8user2*)(objectClass=user))" + + ldb.delete(res[0].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))") + + 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) + 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) + + 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) + assertEquals(res.error, 0) + 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" + 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) + assertEquals(len(res), 1) + + assertEquals(res[0].objectClass[0], "top") + assertEquals(res[0].objectClass[1], "domain") + assertEquals(res[0].objectClass[2], "domainDNS") # check enumeration - 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=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) - -} + 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) - assertEquals(len(res), 1) - - print "Testing for highestCommittedUSN" - attrs = ["highestCommittedUSN"] - res = ldb.search("", "", ldb.SCOPE_BASE, attrs) - assertEquals(res.error, 0) - 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) - 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) - assertEquals(len(res), 0) + print "Testing for all rootDSE attributes" + attrs = [] + res = ldb.search("", "", ldb.SCOPE_BASE, attrs) + assertEquals(res.error, 0) + assertEquals(len(res), 1) + + print "Testing for highestCommittedUSN" + attrs = ["highestCommittedUSN"] + res = ldb.search("", "", ldb.SCOPE_BASE, attrs) + assertEquals(res.error, 0) + 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) + 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) + assertEquals(len(res), 0) def find_basedn(ldb): attrs = ["defaultNamingContext"] @@ -1334,11 +950,8 @@ def find_schemadn(ldb): assertEquals(len(res), 1) return res[0].schemaNamingContext -# use command line creds if available -ldb.credentials = options.get_credentials() -gc_ldb.credentials = options.get_credentials() -ok = ldb.connect("ldap://" + host) +ldb = Ldb("ldap://%s" % host, credentials=creds, session_info=system_session()) base_dn = find_basedn(ldb) configuration_dn = find_configurationdn(ldb) @@ -1346,10 +959,8 @@ schema_dn = find_schemadn(ldb) print "baseDN: %s\n" % base_dn -ok = gc_ldb.connect("ldap://" + host + ":3268") -if (!ok) { - gc_ldb = undefined -} +gc_ldb = Ldb("ldap://%s:3268" % host, credentials=creds, + session_info=system_session()) basic_tests(ldb, gc_ldb, base_dn, configuration_dn, schema_dn) basedn_tests(ldb, gc_ldb) -- cgit From 0098543d676d29385857cc2998304d0270a98813 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 27 Dec 2007 23:32:05 -0600 Subject: r26617: Load smb.conf. (This used to be commit 3f7bfef195421083f1401a73f60c5d270a1455f8) --- source4/lib/ldb/tests/python/ldap.py | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index 898a7336ad..2b5f43920c 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/lib/ldb/tests/python/ldap.py @@ -12,6 +12,7 @@ import samba.getopt as options from auth import system_session from samba import Ldb +import param parser = optparse.OptionParser("ldap [options] ") parser.add_option_group(options.SambaOptions(parser)) @@ -28,6 +29,10 @@ if len(args) < 1: host = args[0] +lp = param.LoadParm() +if opts.configfile: + lp.load(opts.configfile) + def assertEquals(a1, a2): assert a1 == a2 @@ -951,7 +956,8 @@ def find_schemadn(ldb): return res[0].schemaNamingContext -ldb = Ldb("ldap://%s" % host, credentials=creds, session_info=system_session()) +ldb = Ldb("ldap://%s" % host, credentials=creds, session_info=system_session(), + lp=lp) base_dn = find_basedn(ldb) configuration_dn = find_configurationdn(ldb) @@ -960,7 +966,7 @@ schema_dn = find_schemadn(ldb) print "baseDN: %s\n" % base_dn gc_ldb = Ldb("ldap://%s:3268" % host, credentials=creds, - session_info=system_session()) + session_info=system_session(), lp=lp) basic_tests(ldb, gc_ldb, base_dn, configuration_dn, schema_dn) basedn_tests(ldb, gc_ldb) -- cgit From 405a20b44f69812b0225cd12370433842b28c2ca Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 28 Dec 2007 16:25:20 -0600 Subject: r26623: python: Allow specifying URL rather than host name on the command-line. (This used to be commit 108f6caffe2bb311495b89659cfd818f0ec410f2) --- source4/lib/ldb/tests/python/ldap.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index 2b5f43920c..3f70ef9b43 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/lib/ldb/tests/python/ldap.py @@ -955,8 +955,10 @@ def find_schemadn(ldb): assertEquals(len(res), 1) return res[0].schemaNamingContext +if not "://" in host: + host = "ldap://%s" % host -ldb = Ldb("ldap://%s" % host, credentials=creds, session_info=system_session(), +ldb = Ldb(host, credentials=creds, session_info=system_session(), lp=lp) base_dn = find_basedn(ldb) @@ -965,7 +967,7 @@ schema_dn = find_schemadn(ldb) print "baseDN: %s\n" % base_dn -gc_ldb = Ldb("ldap://%s:3268" % host, credentials=creds, +gc_ldb = Ldb("%s:3268" % host, credentials=creds, session_info=system_session(), lp=lp) basic_tests(ldb, gc_ldb, base_dn, configuration_dn, schema_dn) -- cgit From 9269db983d847be7a0cdc9eb2bcc4ebe3066be1c Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 11 Jan 2008 00:23:33 +0100 Subject: python/ldb: Add __getitem__ implementation for LdbMessageElement. (This used to be commit e6498a0780dd31dfc623a69432004b606aeaccbe) --- source4/lib/ldb/tests/python/api.py | 6 ++++++ 1 file changed, 6 insertions(+) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/api.py b/source4/lib/ldb/tests/python/api.py index d9dfce8718..0a5ba035ff 100755 --- a/source4/lib/ldb/tests/python/api.py +++ b/source4/lib/ldb/tests/python/api.py @@ -382,6 +382,12 @@ class MessageElementTests(unittest.TestCase): x = ldb.MessageElement(["foo"]) self.assertEquals(["foo"], list(x)) + def test_get_item(self): + x = ldb.MessageElement(["foo", "bar"]) + self.assertEquals("foo", x[0]) + self.assertEquals("bar", x[1]) + self.assertRaises(KeyError, lambda: x[-1]) + class ExampleModule: name = "example" -- cgit From c3695026e1cfac3e835e937ed9343d82500cf197 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 11 Jan 2008 01:02:58 +0100 Subject: ldb/python: Implement __len__ for MessageElement. (This used to be commit a8f90ed34ce9341080b63c801ef54b82de42b8e6) --- source4/lib/ldb/tests/python/api.py | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/api.py b/source4/lib/ldb/tests/python/api.py index 0a5ba035ff..5ab40106a8 100755 --- a/source4/lib/ldb/tests/python/api.py +++ b/source4/lib/ldb/tests/python/api.py @@ -388,6 +388,10 @@ class MessageElementTests(unittest.TestCase): self.assertEquals("bar", x[1]) self.assertRaises(KeyError, lambda: x[-1]) + def test_len(self): + x = ldb.MessageElement(["foo", "bar"]) + self.assertEquals(2, len(x)) + class ExampleModule: name = "example" -- cgit From 2466d2cc5e210a124bb23cb9d2c8d3cc608a7c7f Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 11 Jan 2008 01:55:56 +0100 Subject: ldb/python: Allow comparing a MessageElement to a list or a singleton. (This used to be commit 1ccbab81d79f83bb419104f2bbaf2ae7b368e90f) --- source4/lib/ldb/tests/python/api.py | 6 ++++++ 1 file changed, 6 insertions(+) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/api.py b/source4/lib/ldb/tests/python/api.py index 5ab40106a8..8469e8f3cd 100755 --- a/source4/lib/ldb/tests/python/api.py +++ b/source4/lib/ldb/tests/python/api.py @@ -392,6 +392,12 @@ class MessageElementTests(unittest.TestCase): x = ldb.MessageElement(["foo", "bar"]) self.assertEquals(2, len(x)) + def test_eq(self): + x = ldb.MessageElement(["foo", "bar"]) + self.assertEquals(["foo", "bar"], x) + x = ldb.MessageElement(["foo"]) + self.assertEquals("foo", x) + class ExampleModule: name = "example" -- cgit From 1f4838b8a3e5f0c7c400097f56329e5a133ec4e8 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 11 Jan 2008 02:36:59 +0100 Subject: python/ldap: Wrap parse_control_strings(). (This used to be commit b27e5a68530c4fd6430cbb174b63f8ff2b6f4e53) --- source4/lib/ldb/tests/python/api.py | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/api.py b/source4/lib/ldb/tests/python/api.py index 8469e8f3cd..236698e382 100755 --- a/source4/lib/ldb/tests/python/api.py +++ b/source4/lib/ldb/tests/python/api.py @@ -62,6 +62,11 @@ class SimpleLdb(unittest.TestCase): self.assertTrue(l.get_opaque("my_opaque") is not None) self.assertEquals(None, l.get_opaque("unknown")) + def test_parse_control_strings(self): + l = ldb.Ldb("foo.tdb") + self.assertRaises(ldb.LdbError, l.parse_control_strings, ["foo", "bar"]) + self.assertTrue(l.parse_control_strings(["paged_results:1:5"]) is not None) + def test_search_scope_base(self): l = ldb.Ldb("foo.tdb") self.assertEquals(len(l.search(ldb.Dn(l, "dc=foo"), -- cgit 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/tests/python/api.py | 22 +++++++++++++--------- 1 file changed, 13 insertions(+), 9 deletions(-) (limited to 'source4/lib/ldb/tests/python') 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 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/lib/ldb/tests/python') 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 ++++++++++++++++-------------------- 1 file changed, 30 insertions(+), 37 deletions(-) (limited to 'source4/lib/ldb/tests/python') 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"]) -- 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 ++++++++++++++---------------------- 1 file changed, 23 insertions(+), 36 deletions(-) (limited to 'source4/lib/ldb/tests/python') 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) -- 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/lib/ldb/tests/python') 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 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) (limited to 'source4/lib/ldb/tests/python') 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) -- 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/lib/ldb/tests/python') 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/lib/ldb/tests/python') 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/tests/python/api.py | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'source4/lib/ldb/tests/python') 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/lib/ldb/tests/python') 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 341ee607b361aed256bfede84f82f790b475d187 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 15 Jan 2008 02:04:20 +0100 Subject: ldap.py: Use constants where possible. (This used to be commit 0885dc9f813e19cd6c28d8259eaeccf1e9b26210) --- source4/lib/ldb/tests/python/ldap.py | 30 ++++++++++++++++-------------- 1 file changed, 16 insertions(+), 14 deletions(-) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index cede927f7a..01b66a3890 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/lib/ldb/tests/python/ldap.py @@ -11,7 +11,10 @@ sys.path.append("scripting/python") import samba.getopt as options from auth import system_session -from ldb import SCOPE_SUBTREE, SCOPE_ONELEVEL, SCOPE_BASE, LdbError +from ldb import (SCOPE_SUBTREE, SCOPE_ONELEVEL, SCOPE_BASE, LdbError, + LDB_ERR_NO_SUCH_OBJECT, LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS, + LDB_ERR_ENTRY_ALREADY_EXISTS, LDB_ERR_UNWILLING_TO_PERFORM, + LDB_ERR_NOT_ALLOWED_ON_NON_LEAF) from samba import Ldb import param @@ -38,7 +41,7 @@ def delete_force(ldb, dn): try: ldb.delete(dn) except LdbError, (num, _): - if num != 32: # LDAP_NO_SUCH_OBJECT + if num != LDB_ERR_NO_SUCH_OBJECT: assert False def assertEquals(a1, a2): @@ -57,7 +60,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, _): - if num != 32: # LDAP_NO_SUCH_OBJECT + if num != LDB_ERR_NO_SUCH_OBJECT: assert False else: assert False @@ -122,8 +125,7 @@ servicePrincipalName: host/ldaptest2computer servicePrincipalName: cifs/ldaptest2computer """) except LdbError, (num, msg): - #LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS - assert num == 20, "Expected error LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS, got : %s" % msg + assert num == LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS ldb.modify_ldif(""" dn: cn=ldaptest2computer,cn=computers,""" + base_dn + """ @@ -140,7 +142,7 @@ add: servicePrincipalName servicePrincipalName: host/ldaptest2computer """) except LdbError, (num, msg): - assert num == 20, "Expected error LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS, got :" + msg + assert num == LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS print "Testing ranged results" ldb.modify_ldif(""" @@ -347,7 +349,7 @@ add: member member: cn=ldaptestuser3,cn=users,""" + base_dn + """ """) except LdbError, (num, _): - assert num == 32 + assert num == LDB_ERR_NO_SUCH_OBJECT else: assert False @@ -391,7 +393,7 @@ member: cn=ldaptestuser3,cn=users,""" + base_dn + """ "objectClass": ["person", "user"], "cn": "LDAPtestUSER3"}) except LdbError, (num, _): - assert num == 68 #LDB_ERR_ENTRY_ALREADY_EXISTS + assert num == LDB_ERR_ENTRY_ALREADY_EXISTS else: assert False @@ -402,7 +404,7 @@ member: cn=ldaptestuser3,cn=users,""" + base_dn + """ 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 + assert num == LDB_ERR_NO_SUCH_OBJECT else: assert False @@ -415,7 +417,7 @@ member: cn=ldaptestuser3,cn=users,""" + base_dn + """ try: ldb.rename("cn=ldaptestuser2,cn=users," + base_dn, "cn=ldaptestuser3,cn=users," + base_dn) except LdbError, (num, _): - assert num == 68 #LDB_ERR_ENTRY_ALREADY_EXISTS + assert num == LDB_ERR_ENTRY_ALREADY_EXISTS else: assert False try: @@ -468,7 +470,7 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """ expression="(&(cn=ldaptestuser4)(objectClass=user))", scope=SCOPE_SUBTREE) except LdbError, (num, _): - assert num == 32 + assert num == LDB_ERR_NO_SUCH_OBJECT else: assert False @@ -476,7 +478,7 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """ try: res = ldb.search("cn=ldaptestcontainer," + base_dn, expression="(&(cn=ldaptestuser4)(objectClass=user))", scope=SCOPE_ONELEVEL) except LdbError, (num, _): - assert num == 32 + assert num == LDB_ERR_NO_SUCH_OBJECT else: assert False @@ -495,7 +497,7 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """ try: ldb.rename("cn=ldaptestcontainer2," + base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer2," + base_dn) except LdbError, (num, _): - assert num == 53 # LDAP_UNWILLING_TO_PERFORM + assert num == LDB_ERR_UNWILLING_TO_PERFORM else: assert False @@ -511,7 +513,7 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """ try: ldb.delete("cn=ldaptestcontainer2," + base_dn) except LdbError, (num, _): - assert num == 66 + assert num == LDB_ERR_NOT_ALLOWED_ON_NON_LEAF else: assert False -- cgit From decdf5954d5e1ae84318d6767317965f544a897f Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 23 Jan 2008 23:33:36 +0100 Subject: python: Add convenience function for getting command line loadparm context and default to using system smb.conf. (This used to be commit b3afde0f00ab5093b577b139a062c233d4db2524) --- source4/lib/ldb/tests/python/ldap.py | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index 01b66a3890..d35f7767df 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/lib/ldb/tests/python/ldap.py @@ -19,7 +19,8 @@ from samba import Ldb import param parser = optparse.OptionParser("ldap [options] ") -parser.add_option_group(options.SambaOptions(parser)) +sambaopts = options.SambaOptions(parser) +parser.add_option_group(sambaopts) parser.add_option_group(options.VersionOptions(parser)) # use command line creds if available credopts = options.CredentialsOptions(parser) @@ -33,9 +34,7 @@ if len(args) < 1: host = args[0] -lp = param.LoadParm() -if opts.configfile: - lp.load(opts.configfile) +lp = sambaopts.get_loadparm() def delete_force(ldb, dn): try: -- cgit From bbf8aca01daeb4519ee12ff1eadf26598dc7a747 Mon Sep 17 00:00:00 2001 From: Andrew Bartlett Date: Fri, 8 Feb 2008 13:23:45 +1100 Subject: Fix syntax in LDAP test We don't get this far in the test at the moment however. Andrew Bartlett (This used to be commit c3098d5c52505e143a6ce498273a5ce6a66220b0) --- source4/lib/ldb/tests/python/ldap.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index d35f7767df..a425ddc830 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/lib/ldb/tests/python/ldap.py @@ -523,12 +523,12 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """ 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_ONELEVEL) - # FIXME: assert len(res) == 0 + 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(expression="(&(cn=ldaptestuser4)(objectClass=user))", base="cn=ldaptestcontainer2," + base_dn, scope=SCOPE_SUBTREE) - #FIXME: assert len(res) == 0 + 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) ldb.delete(("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn)) -- cgit From 8fdd13f18a8268aef61c5634eb2b540f37af257d Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 9 Feb 2008 15:43:28 +0100 Subject: Remove unused path update. (This used to be commit 1868a42108012183aa78fe5d4f524d45f4505a3e) --- source4/lib/ldb/tests/python/ldap.py | 2 -- 1 file changed, 2 deletions(-) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index a425ddc830..02e07c6975 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/lib/ldb/tests/python/ldap.py @@ -6,8 +6,6 @@ import getopt import optparse import sys -# Add path to the library for in-tree use -sys.path.append("scripting/python") import samba.getopt as options from auth import system_session -- cgit From 93bb85d293088d5088c7b5fe6df13def6a4244dd Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 9 Feb 2008 19:04:14 +0100 Subject: Split up tests a bit, output subunit. (This used to be commit 501259ff31641bf52e337b597881d1fedc6b2a63) --- source4/lib/ldb/tests/python/ldap.py | 1474 +++++++++++++++++----------------- 1 file changed, 721 insertions(+), 753 deletions(-) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index 02e07c6975..00bf5d4b38 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/lib/ldb/tests/python/ldap.py @@ -12,9 +12,11 @@ from auth import system_session from ldb import (SCOPE_SUBTREE, SCOPE_ONELEVEL, SCOPE_BASE, LdbError, LDB_ERR_NO_SUCH_OBJECT, LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS, LDB_ERR_ENTRY_ALREADY_EXISTS, LDB_ERR_UNWILLING_TO_PERFORM, - LDB_ERR_NOT_ALLOWED_ON_NON_LEAF) + LDB_ERR_NOT_ALLOWED_ON_NON_LEAF, LDB_ERR_OTHER) from samba import Ldb +from subunit import SubunitTestRunner import param +import unittest parser = optparse.OptionParser("ldap [options] ") sambaopts = options.SambaOptions(parser) @@ -34,122 +36,123 @@ host = args[0] lp = sambaopts.get_loadparm() -def delete_force(ldb, dn): - try: - ldb.delete(dn) - except LdbError, (num, _): - if num != LDB_ERR_NO_SUCH_OBJECT: - assert False - -def assertEquals(a1, a2): - assert a1 == a2, "Expected %r == %r" % (a1, a2) +class BasicTests(unittest.TestCase): + def delete_force(self, ldb, dn): + try: + ldb.delete(dn) + except LdbError, (num, _): + self.assertEquals(num, LDB_ERR_NO_SUCH_OBJECT) + + def find_basedn(self, ldb): + res = ldb.search(base="", expression="", scope=SCOPE_BASE, + attrs=["defaultNamingContext"]) + self.assertEquals(len(res), 1) + return res[0]["defaultNamingContext"][0] + + def find_configurationdn(self, ldb): + res = ldb.search(base="", expression="", scope=SCOPE_BASE, attrs=["configurationNamingContext"]) + self.assertEquals(len(res), 1) + return res[0]["configurationNamingContext"][0] + + def find_schemadn(self, ldb): + res = ldb.search(base="", expression="", scope=SCOPE_BASE, attrs=["schemaNamingContext"]) + self.assertEquals(len(res), 1) + return res[0]["schemaNamingContext"][0] + + def setUp(self): + self.ldb = ldb + self.gc_ldb = gc_ldb + self.base_dn = self.find_basedn(ldb) + self.configuration_dn = self.find_configurationdn(ldb) + self.schema_dn = self.find_schemadn(ldb) + + print "baseDN: %s\n" % self.base_dn + + self.delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn) + self.delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn) + + def test_group_add_invalid_member(self): + """Testing group add with invalid member""" + try: + self.ldb.add({ + "dn": "cn=ldaptestgroup,cn=uSers," + self.base_dn, + "objectclass": "group", + "member": "cn=ldaptestuser,cn=useRs," + self.base_dn}) + except LdbError, (num, _): + self.assertEquals(num, LDB_ERR_NO_SUCH_OBJECT) + else: + self.fail() -def basic_tests(ldb, gc_ldb, base_dn, configuration_dn, schema_dn): - print "Running basic tests" + def test_all(self): + """Basic tests""" - delete_force(ldb, "cn=ldaptestuser,cn=users," + base_dn) - delete_force(ldb, "cn=ldaptestgroup,cn=users," + base_dn) + self.delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn) - print "Testing group add with invalid member" - try: - ldb.add({ - "dn": "cn=ldaptestgroup,cn=uSers," + base_dn, - "objectclass": "group", - "member": "cn=ldaptestuser,cn=useRs," + base_dn}) - except LdbError, (num, _): - if num != LDB_ERR_NO_SUCH_OBJECT: - assert False - else: - assert False - - print "Testing user add" - try: + print "Testing user add" ldb.add({ - "dn": "cn=ldaptestuser,cn=uSers," + base_dn, + "dn": "cn=ldaptestuser,cn=uSers," + self.base_dn, "objectclass": ["user", "person"], "cN": "LDAPtestUSER", "givenname": "ldap", "sn": "testy"}) - except LdbError: - ldb.delete("cn=ldaptestuser,cn=users," + base_dn) - ldb.add({ - "dn": "cn=ldaptestuser,cn=uSers," + base_dn, - "objectclass": ["user", "person"], - "cN": "LDAPtestUSER", - "givenname": "ldap", - "sn": "testy"}) - - ldb.add({ - "dn": "cn=ldaptestgroup,cn=uSers," + base_dn, - "objectclass": "group", - "member": "cn=ldaptestuser,cn=useRs," + base_dn}) - - try: - ldb.add({ - "dn": "cn=ldaptestcomputer,cn=computers," + base_dn, - "objectclass": "computer", - "cN": "LDAPtestCOMPUTER"}) - except LdbError: - ldb.delete("cn=ldaptestcomputer,cn=computers," + base_dn) + ldb.add({ - "dn": "cn=ldaptestcomputer,cn=computers," + base_dn, - "objectClass": "computer", - "cn": "LDAPtestCOMPUTER"}) - - try: - ldb.add({"dn": "cn=ldaptest2computer,cn=computers," + base_dn, - "objectClass": "computer", - "cn": "LDAPtest2COMPUTER", - "userAccountControl": "4096", - "displayname": "ldap testy"}) - except LdbError: - ldb.delete("cn=ldaptest2computer,cn=computers," + base_dn) + "dn": "cn=ldaptestgroup,cn=uSers," + self.base_dn, + "objectclass": "group", + "member": "cn=ldaptestuser,cn=useRs," + self.base_dn}) + + self.delete_force(ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn) ldb.add({ - "dn": "cn=ldaptest2computer,cn=computers," + base_dn, + "dn": "cn=ldaptestcomputer,cn=computers," + self.base_dn, + "objectclass": "computer", + "cN": "LDAPtestCOMPUTER"}) + + self.delete_force(self.ldb, "cn=ldaptest2computer,cn=computers," + self.base_dn) + ldb.add({"dn": "cn=ldaptest2computer,cn=computers," + self.base_dn, "objectClass": "computer", "cn": "LDAPtest2COMPUTER", "userAccountControl": "4096", "displayname": "ldap testy"}) - print "Testing attribute or value exists behaviour" - try: - ldb.modify_ldif(""" -dn: cn=ldaptest2computer,cn=computers,""" + base_dn + """ + print "Testing attribute or value exists behaviour" + try: + ldb.modify_ldif(""" +dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """ changetype: modify replace: servicePrincipalName servicePrincipalName: host/ldaptest2computer servicePrincipalName: host/ldaptest2computer servicePrincipalName: cifs/ldaptest2computer """) - except LdbError, (num, msg): - assert num == LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS + except LdbError, (num, msg): + self.assertEquals(num, LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS) - ldb.modify_ldif(""" -dn: cn=ldaptest2computer,cn=computers,""" + base_dn + """ + ldb.modify_ldif(""" +dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """ changetype: modify replace: servicePrincipalName servicePrincipalName: host/ldaptest2computer servicePrincipalName: cifs/ldaptest2computer """) - try: - ldb.modify_ldif(""" -dn: cn=ldaptest2computer,cn=computers,""" + base_dn + """ + try: + ldb.modify_ldif(""" +dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """ changetype: modify add: servicePrincipalName servicePrincipalName: host/ldaptest2computer """) - except LdbError, (num, msg): - assert num == LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS - - print "Testing ranged results" - ldb.modify_ldif(""" -dn: cn=ldaptest2computer,cn=computers,""" + base_dn + """ + except LdbError, (num, msg): + self.assertEquals(num, LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS) + + print "Testing ranged results" + ldb.modify_ldif(""" +dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """ changetype: modify replace: servicePrincipalName """) - - ldb.modify_ldif(""" -dn: cn=ldaptest2computer,cn=computers,""" + base_dn + """ + + ldb.modify_ldif(""" +dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """ changetype: modify add: servicePrincipalName servicePrincipalName: host/ldaptest2computer0 @@ -184,730 +187,695 @@ servicePrincipalName: host/ldaptest2computer28 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 len(res[0]["servicePrincipalName;range=0-*"]) - assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30) - - 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(len(res[0]["servicePrincipalName;range=0-19"]), 20) - - - 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(len(res[0]["servicePrincipalName;range=0-*"]), 30) - - 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(len(res[0]["servicePrincipalName;range=0-*"]), 30) - - 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(len(res[0]["servicePrincipalName;range=30-*"]), 0) - - - 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(len(res[0]["servicePrincipalName;range=10-*"]), 20) -# pos_11 = res[0]["servicePrincipalName;range=10-*"][18] - - 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(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) - - 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(len(res[0]["servicePrincipalName;range=11-15"]), 5) -# assertEquals(res[0]["servicePrincipalName;range=11-15"][4], pos_11) - - 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(len(res[0]["servicePrincipalName"]), 30) -# assertEquals(res[0]["servicePrincipalName"][18], pos_11) - - try: + res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, + attrs=["servicePrincipalName;range=0-*"]) + self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)") + #print len(res[0]["servicePrincipalName;range=0-*"]) + self.assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30) + + res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-19"]) + self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)") + # print res[0]["servicePrincipalName;range=0-19"].length + self.assertEquals(len(res[0]["servicePrincipalName;range=0-19"]), 20) + + + res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-30"]) + self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)") + self.assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30) + + res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-40"]) + self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)") + self.assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30) + + res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=30-40"]) + self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)") + self.assertEquals(len(res[0]["servicePrincipalName;range=30-*"]), 0) + + + res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=10-40"]) + self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)") + self.assertEquals(len(res[0]["servicePrincipalName;range=10-*"]), 20) + # pos_11 = res[0]["servicePrincipalName;range=10-*"][18] + + res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=11-40"]) + self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)") + self.assertEquals(len(res[0]["servicePrincipalName;range=11-*"]), 19) + # print res[0]["servicePrincipalName;range=11-*"][18] + # print pos_11 + # self.assertEquals((res[0]["servicePrincipalName;range=11-*"][18]), pos_11) + + res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=11-15"]) + self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)") + self.assertEquals(len(res[0]["servicePrincipalName;range=11-15"]), 5) + # self.assertEquals(res[0]["servicePrincipalName;range=11-15"][4], pos_11) + + res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName"]) + self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)") + # print res[0]["servicePrincipalName"][18] + # print pos_11 + self.assertEquals(len(res[0]["servicePrincipalName"]), 30) + # self.assertEquals(res[0]["servicePrincipalName"][18], pos_11) + + self.delete_force(self.ldb, "cn=ldaptestuser2,cn=users," + self.base_dn) ldb.add({ - "dn": "cn=ldaptestuser2,cn=useRs," + base_dn, - "objectClass": ["person", "user"], - "cn": "LDAPtestUSER2", - "givenname": "testy", - "sn": "ldap user2"}) - except LdbError: - ldb.delete("cn=ldaptestuser2,cn=users," + base_dn) - ldb.add({ - "dn": "cn=ldaptestuser2,cn=useRs," + base_dn, - "objectClass": ["person", "user"], - "cn": "LDAPtestUSER2", - "givenname": "testy", - "sn": "ldap user2"}) - - print "Testing Ambigious Name Resolution" -# Testing ldb.search for (&(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(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(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(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(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))") - 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(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(expression="(&(anr==testy ldap)(objectClass=user))") - assert len(res) == 1, "Found only %d for (&(anr==ldap testy)(objectClass=user))" % len(res) - - 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(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(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(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(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))") - 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(expression="(&(anr=not ldap user2)(objectClass=user))") - assert len(res) == 0, "Must not find (&(anr=not ldap user2)(objectClass=user))" - - print "Testing Group Modifies" - ldb.modify_ldif(""" -dn: cn=ldaptestgroup,cn=users,""" + base_dn + """ + "dn": "cn=ldaptestuser2,cn=useRs," + self.base_dn, + "objectClass": ["person", "user"], + "cn": "LDAPtestUSER2", + "givenname": "testy", + "sn": "ldap user2"}) + + print "Testing Ambigious Name Resolution" + # Testing ldb.search for (&(anr=ldap testy)(objectClass=user)) + res = ldb.search(expression="(&(anr=ldap testy)(objectClass=user))") + self.assertEquals(len(res), 3, "Could not find (&(anr=ldap testy)(objectClass=user))") + + # Testing ldb.search for (&(anr=testy ldap)(objectClass=user)) + res = ldb.search(expression="(&(anr=testy ldap)(objectClass=user))") + self.assertEquals(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(expression="(&(anr=ldap)(objectClass=user))") + self.assertEquals(len(res), 4, "Found only %d for (&(anr=ldap)(objectClass=user))" % len(res)) + + # Testing ldb.search for (&(anr==ldap)(objectClass=user)) + res = ldb.search(expression="(&(anr==ldap)(objectClass=user))") + self.assertEquals(len(res), 1, "Could not find (&(anr==ldap)(objectClass=user)). Found only %d for (&(anr=ldap)(objectClass=user))" % len(res)) + + self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn)) + self.assertEquals(res[0]["cn"][0], "ldaptestuser") + self.assertEquals(res[0]["name"], "ldaptestuser") + + # Testing ldb.search for (&(anr=testy)(objectClass=user)) + res = ldb.search(expression="(&(anr=testy)(objectClass=user))") + self.assertEquals(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(expression="(&(anr=testy ldap)(objectClass=user))") + self.assertEquals(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(expression="(&(anr==testy ldap)(objectClass=user))") + self.assertEquals(len(res), 1, "Found only %d for (&(anr==ldap testy)(objectClass=user))" % len(res)) + + self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn)) + self.assertEquals(res[0]["cn"][0], "ldaptestuser") + self.assertEquals(res[0]["name"][0], "ldaptestuser") + + # Testing ldb.search for (&(anr==testy ldap)(objectClass=user)) + res = ldb.search(expression="(&(anr==testy ldap)(objectClass=user))") + self.assertEquals(len(res), 1, "Could not find (&(anr==testy ldap)(objectClass=user))") + + self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn)) + self.assertEquals(res[0]["cn"][0], "ldaptestuser") + self.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))") + self.assertEquals(len(res), 1, "Could not find (&(anr=testy ldap user)(objectClass=user))") + + self.assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn)) + self.assertEquals(res[0]["cn"], "ldaptestuser2") + self.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))") + self.assertEquals(len(res), 1, "Could not find (&(anr==testy ldap user2)(objectClass=user))") + + self.assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn)) + self.assertEquals(res[0]["cn"], "ldaptestuser2") + self.assertEquals(res[0]["name"], "ldaptestuser2") + + # Testing ldb.search for (&(anr==ldap user2)(objectClass=user)) + res = ldb.search(expression="(&(anr==ldap user2)(objectClass=user))") + self.assertEquals(len(res), 1, "Could not find (&(anr==ldap user2)(objectClass=user))") + + self.assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn)) + self.assertEquals(res[0]["cn"], "ldaptestuser2") + self.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))") + self.assertEquals(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(expression="(&(anr=not ldap user2)(objectClass=user))") + self.assertEquals(len(res), 0, "Must not find (&(anr=not ldap user2)(objectClass=user))") + + print "Testing Group Modifies" + ldb.modify_ldif(""" +dn: cn=ldaptestgroup,cn=users,""" + self.base_dn + """ changetype: modify add: member -member: cn=ldaptestuser2,cn=users,""" + base_dn + """ -member: cn=ldaptestcomputer,cn=computers,""" + base_dn + """ +member: cn=ldaptestuser2,cn=users,""" + self.base_dn + """ +member: cn=ldaptestcomputer,cn=computers,""" + self.base_dn + """ """) - delete_force(ldb, "cn=ldaptestuser3,cn=users," + base_dn) + self.delete_force(ldb, "cn=ldaptestuser3,cn=users," + self.base_dn) - print "Testing adding non-existent user to a group" - try: - ldb.modify_ldif(""" -dn: cn=ldaptestgroup,cn=users,""" + base_dn + """ + print "Testing adding non-existent user to a group" + try: + ldb.modify_ldif(""" +dn: cn=ldaptestgroup,cn=users,""" + self.base_dn + """ changetype: modify add: member -member: cn=ldaptestuser3,cn=users,""" + base_dn + """ +member: cn=ldaptestuser3,cn=users,""" + self.base_dn + """ """) - except LdbError, (num, _): - assert num == LDB_ERR_NO_SUCH_OBJECT - else: - assert False - - print "Testing Renames" - - ldb.rename("cn=ldaptestuser2,cn=users," + base_dn, "cn=ldaptestuser3,cn=users," + base_dn) - - 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(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 + ")" -# 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(len(res), 1) -# } -# assertEquals(res[0].dn, ("CN=ldaptestUSER3,CN=Users," + base_dn)) -# assertEquals(res[0].cn, "ldaptestUSER3") -# assertEquals(res[0].name, "ldaptestUSER3") - - 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(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: - ldb.add({"dn": "cn=ldaptestuser3,cn=userS," + base_dn, - "objectClass": ["person", "user"], - "cn": "LDAPtestUSER3"}) - except LdbError, (num, _): - assert num == LDB_ERR_ENTRY_ALREADY_EXISTS - else: - assert False - - # rename back - ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser2,cn=users," + base_dn) - - # ensure we cannnot rename it twice - try: - ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser2,cn=users," + base_dn) - except LdbError, (num, _): - assert num == LDB_ERR_NO_SUCH_OBJECT - else: - assert False - - # ensure can now use that name - ldb.add({"dn": "cn=ldaptestuser3,cn=users," + base_dn, - "objectClass": ["person", "user"], - "cn": "LDAPtestUSER3"}) - - # ensure we now cannnot rename - try: - ldb.rename("cn=ldaptestuser2,cn=users," + base_dn, "cn=ldaptestuser3,cn=users," + base_dn) - except LdbError, (num, _): - assert num == LDB_ERR_ENTRY_ALREADY_EXISTS - else: - assert False - try: - ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser3,cn=configuration," + base_dn) - except LdbError, (num, _): - assert num in (71, 64) - else: - assert False - - ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser5,cn=users," + base_dn) - - ldb.delete("cn=ldaptestuser5,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"}) - - try: - ldb.add({"dn": "CN=ldaptestuser4,CN=ldaptestcontainer," + base_dn, - "objectClass": ["person", "user"], - "cn": "LDAPtestUSER4"}) - except LdbError: - ldb.delete("cn=ldaptestuser4,cn=ldaptestcontainer," + base_dn) - ldb.add({"dn": "CN=ldaptestuser4,CN=ldaptestcontainer," + base_dn, + except LdbError, (num, _): + self.assertEquals(num, LDB_ERR_NO_SUCH_OBJECT) + else: + self.fail() + + print "Testing Renames" + + ldb.rename("cn=ldaptestuser2,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=users," + self.base_dn) + + ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=users," + self.base_dn) + + ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestUSER3,cn=users," + self.base_dn) + + print "Testing ldb.search for (&(cn=ldaptestuser3)(objectClass=user))" + res = ldb.search(expression="(&(cn=ldaptestuser3)(objectClass=user))") + self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser3)(objectClass=user))") + + self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn)) + self.assertEquals(res[0]["cn"], "ldaptestUSER3") + self.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," + self.base_dn + ")" + # res = ldb.search("(dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")") + # if (res.error != 0 || len(res) != 1) { + # print "Could not find (dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")" + # self.assertEquals(len(res), 1) + # } + # self.assertEquals(res[0].dn, ("CN=ldaptestUSER3,CN=Users," + self.base_dn)) + # self.assertEquals(res[0].cn, "ldaptestUSER3") + # self.assertEquals(res[0].name, "ldaptestUSER3") + + print "Testing ldb.search for (distinguishedName=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")" + res = ldb.search(expression="(distinguishedName=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")") + self.assertEquals(len(res), 1, "Could not find (dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")") + self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn)) + self.assertEquals(res[0]["cn"], "ldaptestUSER3") + self.assertEquals(res[0]["name"], "ldaptestUSER3") + + # ensure we cannot add it again + try: + ldb.add({"dn": "cn=ldaptestuser3,cn=userS," + self.base_dn, "objectClass": ["person", "user"], - "cn": "LDAPtestUSER4"}) + "cn": "LDAPtestUSER3"}) + except LdbError, (num, _): + self.assertEquals(num, LDB_ERR_ENTRY_ALREADY_EXISTS) + else: + self.fail() + + # rename back + ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser2,cn=users," + self.base_dn) + + # ensure we cannnot rename it twice + try: + ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser2,cn=users," + self.base_dn) + except LdbError, (num, _): + self.assertEquals(num, LDB_ERR_NO_SUCH_OBJECT) + else: + self.fail() + + # ensure can now use that name + ldb.add({"dn": "cn=ldaptestuser3,cn=users," + self.base_dn, + "objectClass": ["person", "user"], + "cn": "LDAPtestUSER3"}) + + # ensure we now cannnot rename + try: + ldb.rename("cn=ldaptestuser2,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=users," + self.base_dn) + except LdbError, (num, _): + self.assertEquals(num, LDB_ERR_ENTRY_ALREADY_EXISTS) + else: + self.fail() + try: + ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=configuration," + self.base_dn) + except LdbError, (num, _): + self.assertTrue(num in (71, 64)) + else: + self.fail() + + ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser5,cn=users," + self.base_dn) + + ldb.delete("cn=ldaptestuser5,cn=users," + self.base_dn) + + self.delete_force(ldb, "cn=ldaptestgroup2,cn=users," + self.base_dn) + + ldb.rename("cn=ldaptestgroup,cn=users," + self.base_dn, "cn=ldaptestgroup2,cn=users," + self.base_dn) + + print "Testing subtree Renames" - ldb.modify_ldif(""" -dn: cn=ldaptestgroup2,cn=users,""" + base_dn + """ + ldb.add({"dn": "cn=ldaptestcontainer," + self.base_dn, + "objectClass": "container"}) + + self.delete_force(self.ldb, "cn=ldaptestuser4,cn=ldaptestcontainer," + self.base_dn) + ldb.add({"dn": "CN=ldaptestuser4,CN=ldaptestcontainer," + self.base_dn, + "objectClass": ["person", "user"], + "cn": "LDAPtestUSER4"}) + + ldb.modify_ldif(""" +dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """ changetype: modify add: member -member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """ +member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """ """) - - print "Testing ldb.rename of cn=ldaptestcontainer," + base_dn + " to cn=ldaptestcontainer2," + base_dn - ldb.rename("CN=ldaptestcontainer," + base_dn, "CN=ldaptestcontainer2," + base_dn) - - print "Testing ldb.search for (&(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: - ldb.search("cn=ldaptestcontainer," + base_dn, - expression="(&(cn=ldaptestuser4)(objectClass=user))", - scope=SCOPE_SUBTREE) - except LdbError, (num, _): - assert num == LDB_ERR_NO_SUCH_OBJECT - else: - assert False - - print "Testing one-level 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_ONELEVEL) - except LdbError, (num, _): - assert num == LDB_ERR_NO_SUCH_OBJECT - else: - assert False - - print "Testing ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in renamed container" - 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(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, 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: - ldb.rename("cn=ldaptestcontainer2," + base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer2," + base_dn) - except LdbError, (num, _): - assert num == LDB_ERR_UNWILLING_TO_PERFORM - else: - assert False - - print "Testing ldb.rename (into non-existent container) of cn=ldaptestcontainer2," + base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer3," + base_dn - try: - ldb.rename("cn=ldaptestcontainer2," + base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer3," + base_dn) - except LdbError, (num, _): - assert num in (53, 80) - else: - assert False - - print "Testing delete (should fail, not a leaf node) of renamed cn=ldaptestcontainer2," + base_dn - try: - ldb.delete("cn=ldaptestcontainer2," + base_dn) - except LdbError, (num, _): - assert num == LDB_ERR_NOT_ALLOWED_ON_NON_LEAF - else: - assert False - - print "Testing base ldb.search for CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn - res = ldb.search(expression="(objectclass=*)", base=("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn), scope=SCOPE_BASE) - assert len(res) == 1 - 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(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(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) - ldb.delete(("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn)) - print "Testing delete of renamed cn=ldaptestcontainer2," + base_dn - ldb.delete("cn=ldaptestcontainer2," + base_dn) - - try: - ldb.add({"dn": "cn=ldaptestutf8user èùéìòà ,cn=users," + base_dn, "objectClass": "user"}) - except LdbError, (num, _): - ldb.delete("cn=ldaptestutf8user èùéìòà ,cn=users," + base_dn) - ldb.add({"dn": "cn=ldaptestutf8user èùéìòà ,cn=users," + base_dn, "objectClass": "user"}) - - try: - ldb.add({"dn": "cn=ldaptestutf8user2 èùéìòà ,cn=users," + base_dn, "objectClass": "user"}) - except LdbError, (num, _): - ldb.delete("cn=ldaptestutf8user2 èùéìòà ,cn=users," + base_dn) - ldb.add({"dn": "cn=ldaptestutf8user2 èùéìòà ,cn=users," + base_dn, - "objectClass": "user"}) - - print "Testing ldb.search for (&(cn=ldaptestuser)(objectClass=user))" - res = ldb.search(expression="(&(cn=ldaptestuser)(objectClass=user))") - assert len(res) == 1, "Could not find (&(cn=ldaptestuser)(objectClass=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" 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"][0]), 805306368) -# assertEquals(res[0].userAccountControl, 546) - 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[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[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[0].dn) - - print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon)) in with 'phantom root' control" - - 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[0].dn) - - ldb.delete(res[0].dn) - - print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectClass=user))" - res = ldb.search(expression="(&(cn=ldaptestcomputer)(objectClass=user))") - assert len(res) == 1, "Could not find (&(cn=ldaptestuser)(objectClass=user))" - - 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" in res[0]) - assert("whenCreated" in res[0]) - assertEquals(res[0]["objectCategory"], ("CN=Computer,CN=Schema,CN=Configuration," + base_dn)) - 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) - 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[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[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[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[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[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[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[0].dn) - - ldb.delete(res[0].dn) - - print "Testing ldb.search for (&(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"], ["top", "person", "organizationalPerson", "user", "computer"]) - 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, 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" 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, 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"], ["top", "group"]) - assert("objectGuid" not in res[0]) - 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 + """ + + print "Testing ldb.rename of cn=ldaptestcontainer," + self.base_dn + " to cn=ldaptestcontainer2," + self.base_dn + ldb.rename("CN=ldaptestcontainer," + self.base_dn, "CN=ldaptestcontainer2," + self.base_dn) + + print "Testing ldb.search for (&(cn=ldaptestuser4)(objectClass=user))" + res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))") + self.assertEquals(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," + self.base_dn + try: + ldb.search("cn=ldaptestcontainer," + self.base_dn, + expression="(&(cn=ldaptestuser4)(objectClass=user))", + scope=SCOPE_SUBTREE) + except LdbError, (num, _): + self.assertEquals(num, LDB_ERR_NO_SUCH_OBJECT) + else: + self.fail() + + print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + self.base_dn + try: + res = ldb.search("cn=ldaptestcontainer," + self.base_dn, + expression="(&(cn=ldaptestuser4)(objectClass=user))", scope=SCOPE_ONELEVEL) + except LdbError, (num, _): + self.assertEquals(num, LDB_ERR_NO_SUCH_OBJECT) + else: + self.fail() + + print "Testing ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in renamed container" + res = ldb.search("cn=ldaptestcontainer2," + self.base_dn, expression="(&(cn=ldaptestuser4)(objectClass=user))", scope=SCOPE_SUBTREE) + self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser4)(objectClass=user)) under cn=ldaptestcontainer2," + self.base_dn) + + self.assertEquals(str(res[0].dn), ("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn)) + self.assertEquals(res[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper()) + + print "Testing ldb.search for (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group)) to check subtree renames and linked attributes" + res = ldb.search(self.base_dn, expression="(&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group))", scope=SCOPE_SUBTREE) + self.assertEquals(len(res), 1, "Could not find (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group)), perhaps linked attributes are not conistant with subtree renames?") + + print "Testing ldb.rename (into itself) of cn=ldaptestcontainer2," + self.base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer2," + self.base_dn + try: + ldb.rename("cn=ldaptestcontainer2," + self.base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer2," + self.base_dn) + except LdbError, (num, _): + self.assertEquals(num, LDB_ERR_UNWILLING_TO_PERFORM) + else: + self.fail() + + print "Testing ldb.rename (into non-existent container) of cn=ldaptestcontainer2," + self.base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer3," + self.base_dn + try: + ldb.rename("cn=ldaptestcontainer2," + self.base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer3," + self.base_dn) + except LdbError, (num, _): + self.assertTrue(num in (LDB_ERR_UNWILLING_TO_PERFORM, LDB_ERR_OTHER)) + else: + self.fail() + + print "Testing delete (should fail, not a leaf node) of renamed cn=ldaptestcontainer2," + self.base_dn + try: + ldb.delete("cn=ldaptestcontainer2," + self.base_dn) + except LdbError, (num, _): + self.assertEquals(num, LDB_ERR_NOT_ALLOWED_ON_NON_LEAF) + else: + self.fail() + + print "Testing base ldb.search for CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + res = ldb.search(expression="(objectclass=*)", base=("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn), scope=SCOPE_BASE) + self.assertEquals(len(res), 1) + res = ldb.search(expression="(cn=ldaptestuser40)", base=("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn), scope=SCOPE_BASE) + self.assertEquals(len(res), 0) + + print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in cn=ldaptestcontainer2," + self.base_dn + res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))", base=("cn=ldaptestcontainer2," + self.base_dn), scope=SCOPE_ONELEVEL) + self.assertEquals(len(res), 0) + + print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in cn=ldaptestcontainer2," + self.base_dn + res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))", base=("cn=ldaptestcontainer2," + self.base_dn), scope=SCOPE_SUBTREE) + self.assertEquals(len(res), 0) + + print "Testing delete of subtree renamed "+("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn) + ldb.delete(("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn)) + print "Testing delete of renamed cn=ldaptestcontainer2," + self.base_dn + ldb.delete("cn=ldaptestcontainer2," + self.base_dn) + + self.delete_force(self.ldb, "cn=ldaptestutf8user èùéìòà ,cn=users," + self.base_dn) + ldb.add({"dn": "cn=ldaptestutf8user èùéìòà ,cn=users," + self.base_dn, "objectClass": "user"}) + + self.delete_force(self.ldb, "cn=ldaptestutf8user2 èùéìòà ,cn=users," + self.base_dn) + ldb.add({"dn": "cn=ldaptestutf8user2 èùéìòà ,cn=users," + self.base_dn, "objectClass": "user"}) + + print "Testing ldb.search for (&(cn=ldaptestuser)(objectClass=user))" + res = ldb.search(expression="(&(cn=ldaptestuser)(objectClass=user))") + self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser)(objectClass=user))") + + self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn)) + self.assertEquals(res[0]["cn"], "ldaptestuser") + self.assertEquals(res[0]["name"], "ldaptestuser") + self.assertEquals(res[0]["objectClass"], ["top", "person", "organizationalPerson", "user"]) + self.assertTrue("objectGUID" in res[0]) + self.assertTrue("whenCreated" in res[0]) + self.assertEquals(res[0]["objectCategory"], ("CN=Person,CN=Schema,CN=Configuration," + self.base_dn)) + self.assertEquals(int(res[0]["sAMAccountType"][0]), 805306368) + # self.assertEquals(res[0].userAccountControl, 546) + self.assertEquals(res[0]["memberOf"][0], ("CN=ldaptestgroup2,CN=Users," + self.base_dn)) + self.assertEquals(len(res[0]["memberOf"]), 1) + + print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + self.base_dn + "))" + res2 = ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + self.base_dn + "))") + self.assertEquals(len(res2), 1, "Could not find (&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + self.base_dn + "))") + + self.assertEquals(res[0].dn, res2[0].dn) + + print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon))" + res3 = ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=PerSon))") + self.assertEquals(len(res3), 1, "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)): matched " + len(res3)) + + self.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))") + self.assertEquals(len(res3gc), 1) + + self.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(self.base_dn, expression="(&(cn=ldaptestuser)(objectCategory=PerSon))", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:2"]) + self.assertEquals(len(res3control), 1, "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog") + + self.assertEquals(res[0].dn, res3control[0].dn) + + ldb.delete(res[0].dn) + + print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectClass=user))" + res = ldb.search(expression="(&(cn=ldaptestcomputer)(objectClass=user))") + self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser)(objectClass=user))") + + self.assertEquals(str(res[0].dn), ("CN=ldaptestcomputer,CN=Computers," + self.base_dn)) + self.assertEquals(res[0]["cn"], "ldaptestcomputer") + self.assertEquals(res[0]["name"], "ldaptestcomputer") + self.assertEquals(res[0]["objectClass"], ["top", "person", "organizationalPerson", "user", "computer"]) + self.assertTrue("objectGUID" in res[0]) + self.assertTrue("whenCreated" in res[0]) + self.assertEquals(res[0]["objectCategory"], ("CN=Computer,CN=Schema,CN=Configuration," + self.base_dn)) + self.assertEquals(int(res[0]["primaryGroupID"][0]), 513) + # self.assertEquals(res[0].sAMAccountType, 805306368) + # self.assertEquals(res[0].userAccountControl, 546) + self.assertEquals(res[0]["memberOf"][0], "CN=ldaptestgroup2,CN=Users," + self.base_dn) + self.assertEquals(len(res[0]["memberOf"]), 1) + + print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + self.base_dn + "))" + res2 = ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + self.base_dn + "))") + self.assertEquals(len(res2), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + self.base_dn + "))") + + self.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," + self.base_dn + ")) in Global Catlog" + res2gc = gc_ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + self.base_dn + "))") + self.assertEquals(len(res2gc), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + self.base_dn + ")) in Global Catlog") + + self.assertEquals(res[0].dn, res2gc[0].dn) + + print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER))" + res3 = ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=compuTER))") + self.assertEquals(len(res3), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER))") + + self.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))") + self.assertEquals(len(res3gc), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog") + + self.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))") + self.assertEquals(len(res4), 1, "Could not find (&(cn=ldaptestcomp*r)(objectCategory=compuTER))") + + self.assertEquals(res[0].dn, res4[0].dn) + + print "Testing ldb.search for (&(cn=ldaptestcomput*)(objectCategory=compuTER))" + res5 = ldb.search(expression="(&(cn=ldaptestcomput*)(objectCategory=compuTER))") + self.assertEquals(len(res5), 1, "Could not find (&(cn=ldaptestcomput*)(objectCategory=compuTER))") + + self.assertEquals(res[0].dn, res5[0].dn) + + print "Testing ldb.search for (&(cn=*daptestcomputer)(objectCategory=compuTER))" + res6 = ldb.search(expression="(&(cn=*daptestcomputer)(objectCategory=compuTER))") + self.assertEquals(len(res6), 1, "Could not find (&(cn=*daptestcomputer)(objectCategory=compuTER))") + + self.assertEquals(res[0].dn, res6[0].dn) + + ldb.delete(res[0].dn) + + print "Testing ldb.search for (&(cn=ldaptest2computer)(objectClass=user))" + res = ldb.search(expression="(&(cn=ldaptest2computer)(objectClass=user))") + self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptest2computer)(objectClass=user))") + + self.assertEquals(res[0].dn, ("CN=ldaptest2computer,CN=Computers," + self.base_dn)) + self.assertEquals(res[0]["cn"], "ldaptest2computer") + self.assertEquals(res[0]["name"], "ldaptest2computer") + self.assertEquals(res[0]["objectClass"], ["top", "person", "organizationalPerson", "user", "computer"]) + self.assertTrue("objectGUID" in res[0]) + self.assertTrue("whenCreated" in res[0]) + self.assertEquals(res[0]["objectCategory"][0], "CN=Computer,CN=Schema,CN=Configuration," + self.base_dn) + self.assertEquals(int(res[0]["sAMAccountType"][0]), 805306369) + # self.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(self.base_dn, expression="(&(cn=ldaptestUSer2)(objectClass=user))", scope=SCOPE_SUBTREE, attrs=attrs) + self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestUSer2)(objectClass=user))") + + self.assertEquals(res[0].dn, ("CN=ldaptestuser2,CN=Users," + self.base_dn)) + self.assertEquals(res[0]["cn"], "ldaptestuser2") + self.assertEquals(res[0]["name"], "ldaptestuser2") + self.assertEquals(res[0]["objectClass"], ["top", "person", "organizationalPerson", "user"]) + self.assertTrue("objectGUID" in res[0]) + self.assertTrue("whenCreated" in res[0]) + self.assertTrue("nTSecurityDescriptor" in res[0]) + self.assertEquals(res[0]["memberOf"][0], ("CN=ldaptestgroup2,CN=Users," + self.base_dn)) + + attrs = ["cn", "name", "objectClass", "objectGUID", "whenCreated", "nTSecurityDescriptor", "member"] + print "Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group))" + res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs) + self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))") + + self.assertEquals(res[0].dn, ("CN=ldaptestgroup2,CN=Users," + self.base_dn)) + self.assertEquals(res[0]["cn"], "ldaptestgroup2") + self.assertEquals(res[0]["name"], "ldaptestgroup2") + self.assertEquals(res[0]["objectClass"], ["top", "group"]) + self.assertTrue("objectGuid" not in res[0]) + self.assertTrue("whenCreated" in res[0]) + self.assertTrue("nTSecurityDescriptor" in res[0]) + self.assertEquals(res[0]["member"], ["CN=ldaptestuser2,CN=Users," + self.base_dn]) + + ldb.modify_ldif(""" +dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """ changetype: modify replace: member -member: CN=ldaptestuser2,CN=Users,""" + base_dn + """ -member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """ +member: CN=ldaptestuser2,CN=Users,""" + self.base_dn + """ +member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """ """) - - print "Testing Linked attribute behaviours" - ldb.modify_ldif(""" -dn: cn=ldaptestgroup2,cn=users,""" + base_dn + """ + + print "Testing Linked attribute behaviours" + ldb.modify_ldif(""" +dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """ changetype: modify delete: member """) - ldb.modify_ldif(""" -dn: cn=ldaptestgroup2,cn=users,""" + base_dn + """ + ldb.modify_ldif(""" +dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """ changetype: modify add: member -member: CN=ldaptestuser2,CN=Users,""" + base_dn + """ -member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """ +member: CN=ldaptestuser2,CN=Users,""" + self.base_dn + """ +member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """ """) - - ldb.modify_ldif(""" -dn: cn=ldaptestgroup2,cn=users,""" + base_dn + """ + + ldb.modify_ldif(""" +dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """ changetype: modify replace: member """) - - ldb.modify_ldif(""" -dn: cn=ldaptestgroup2,cn=users,""" + base_dn + """ + + ldb.modify_ldif(""" +dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """ changetype: modify add: member -member: CN=ldaptestuser2,CN=Users,""" + base_dn + """ -member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """ +member: CN=ldaptestuser2,CN=Users,""" + self.base_dn + """ +member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """ """) - - ldb.modify_ldif(""" -dn: cn=ldaptestgroup2,cn=users,""" + base_dn + """ + + ldb.modify_ldif(""" +dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """ changetype: modify delete: member -member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + base_dn + """ +member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """ """) - - 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))" + + res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs) + self.assertEquals(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(len(res[0]["member"]), 1) + self.assertEquals(res[0].dn, ("CN=ldaptestgroup2,CN=Users," + self.base_dn)) + self.assertEquals(res[0]["member"][0], ("CN=ldaptestuser2,CN=Users," + self.base_dn)) + self.assertEquals(len(res[0]["member"]), 1) - ldb.delete(("CN=ldaptestuser2,CN=Users," + base_dn)) + ldb.delete(("CN=ldaptestuser2,CN=Users," + self.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, 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" + attrs = ["cn", "name", "objectClass", "objectGUID", "whenCreated", "nTSecurityDescriptor", "member"] + print "Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete" + res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs) + self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete") - assertEquals(res[0].dn, ("CN=ldaptestgroup2,CN=Users," + base_dn)) - assert("member" not in res[0]) + self.assertEquals(res[0].dn, ("CN=ldaptestgroup2,CN=Users," + self.base_dn)) + self.assertTrue("member" not in res[0]) - print "Testing ldb.search for (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))" - res = ldb.search(expression="(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))") - assert len(res) == 1, "Could not find (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))" + print "Testing ldb.search for (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))" + res = ldb.search(expression="(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))") + self.assertEquals(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"], ["top", "person", "organizationalPerson", "user"]) - assert("objectGUID" in res[0]) - assert("whenCreated" in res[0]) + self.assertEquals(res[0].dn, ("CN=ldaptestutf8user èùéìòà,CN=Users," + self.base_dn)) + self.assertEquals(res[0]["cn"], "ldaptestutf8user èùéìòà") + self.assertEquals(res[0]["name"], "ldaptestutf8user èùéìòà") + self.assertEquals(res[0]["objectClass"], ["top", "person", "organizationalPerson", "user"]) + self.assertTrue("objectGUID" in res[0]) + self.assertTrue("whenCreated" in res[0]) - ldb.delete(res[0].dn) + ldb.delete(res[0].dn) - print "Testing ldb.search for (&(cn=ldaptestutf8user2*)(objectClass=user))" - res = ldb.search(expression="(&(cn=ldaptestutf8user2*)(objectClass=user))") - assert len(res) == 1, "Could not find (&(cn=ldaptestutf8user2*)(objectClass=user))" + print "Testing ldb.search for (&(cn=ldaptestutf8user2*)(objectClass=user))" + res = ldb.search(expression="(&(cn=ldaptestutf8user2*)(objectClass=user))") + self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestutf8user2*)(objectClass=user))") - ldb.delete(res[0].dn) + ldb.delete(res[0].dn) - ldb.delete(("CN=ldaptestgroup2,CN=Users," + base_dn)) + ldb.delete(("CN=ldaptestgroup2,CN=Users," + self.base_dn)) - print "Testing ldb.search for (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))" - res = ldb.search(expression="(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))") + print "Testing ldb.search for (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))" + res = ldb.search(expression="(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))") - #FIXME: assert len(res) == 1, "Could not find (expect space collapse, win2k3 fails) (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))" + #FIXME: self.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, 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't get at the configuration DN from the main search base" + res = ldb.search(self.base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"]) + self.assertEquals(len(res), 0, "Got configuration DN " + res[0].dn + " which should not be able to be seen from main search base") + self.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, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:2"]) - assert(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(self.base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:2"]) + self.assertTrue(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" + 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(self.base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:0"]) + self.assertTrue(len(res) > 0) + + print "Testing that we do find configuration elements in the global catlog" + res = gc_ldb.search(self.base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"]) + self.assertTrue(len(res) > 0) + + print "Testing that we do find configuration elements and user elements at the same time" + res = gc_ldb.search(self.base_dn, expression="(|(objectClass=crossRef)(objectClass=person))", scope=SCOPE_SUBTREE, attrs=["cn"]) + self.assertTrue(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, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"]) + self.assertTrue(len(res) > 0) + + print "Testing that we can get at the configuration DN on the main LDAP port" + res = ldb.search(configuration_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"]) + self.assertTrue(len(res) > 0) + + print "Testing objectCategory canonacolisation" + res = ldb.search(configuration_dn, expression="objectCategory=ntDsDSA", scope=SCOPE_SUBTREE, attrs=["cn"]) + self.assertTrue(len(res) > 0, "Didn't find any records with objectCategory=ntDsDSA") + self.assertTrue(len(res) != 0) + + res = ldb.search(configuration_dn, expression="objectCategory=CN=ntDs-DSA," + schema_dn, scope=SCOPE_SUBTREE, attrs=["cn"]) + self.assertTrue(len(res) > 0, "Didn't find any records with objectCategory=CN=ntDs-DSA," + schema_dn) + self.assertTrue(len(res) != 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, 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, 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, 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, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"]) - assert (len(res) > 0) - - print "Testing objectCategory canonacolisation" - 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, 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) - - print "Testing objectClass attribute order on "+ base_dn - res = ldb.search(expression="objectClass=domain", base=base_dn, - scope=SCOPE_BASE, attrs=["objectClass"]) - assertEquals(len(res), 1) - - assertEquals(res[0]["objectClass"], ["top", "domain", "domainDNS"]) - -# check enumeration - - print "Testing ldb.search for objectCategory=person" - 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, 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, 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, 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, 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, expression="objectCategory=group", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"]) - assert(len(res) > 0) - -def basedn_tests(ldb, gc_ldb): - print "Testing for all rootDSE attributes" - res = ldb.search(scope=SCOPE_BASE, attrs=[]) - assertEquals(len(res), 1) - - print "Testing for highestCommittedUSN" - res = ldb.search("", scope=SCOPE_BASE, attrs=["highestCommittedUSN"]) - assertEquals(len(res), 1) - assert(int(res[0]["highestCommittedUSN"][0]) != 0) - - print "Testing for netlogon via LDAP" - 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, - 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) - return res[0]["schemaNamingContext"][0] + print "Testing objectClass attribute order on "+ self.base_dn + res = ldb.search(expression="objectClass=domain", base=self.base_dn, + scope=SCOPE_BASE, attrs=["objectClass"]) + self.assertEquals(len(res), 1) + + self.assertEquals(res[0]["objectClass"], ["top", "domain", "domainDNS"]) + + # check enumeration + + print "Testing ldb.search for objectCategory=person" + res = ldb.search(self.base_dn, expression="objectCategory=person", scope=SCOPE_SUBTREE, attrs=["cn"]) + self.assertTrue(len(res) > 0) + + print "Testing ldb.search for objectCategory=person with domain scope control" + res = ldb.search(self.base_dn, expression="objectCategory=person", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"]) + self.assertTrue(len(res) > 0) + + print "Testing ldb.search for objectCategory=user" + res = ldb.search(self.base_dn, expression="objectCategory=user", scope=SCOPE_SUBTREE, attrs=["cn"]) + self.assertTrue(len(res) > 0) + + print "Testing ldb.search for objectCategory=user with domain scope control" + res = ldb.search(self.base_dn, expression="objectCategory=user", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"]) + self.assertTrue(len(res) > 0) + + print "Testing ldb.search for objectCategory=group" + res = ldb.search(self.base_dn, expression="objectCategory=group", scope=SCOPE_SUBTREE, attrs=["cn"]) + self.assertTrue(len(res) > 0) + + print "Testing ldb.search for objectCategory=group with domain scope control" + res = ldb.search(self.base_dn, expression="objectCategory=group", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["domain_scope:1"]) + self.assertTrue(len(res) > 0) + + +class BaseDnTests(unittest.TestCase): + def setUp(self): + self.ldb = ldb + + def test_rootdse_attrs(self): + """Testing for all rootDSE attributes""" + res = self.ldb.search(scope=SCOPE_BASE, attrs=[]) + self.assertEquals(len(res), 1) + + def test_highestcommittedusn(self): + """Testing for highestCommittedUSN""" + res = self.ldb.search("", scope=SCOPE_BASE, attrs=["highestCommittedUSN"]) + self.assertEquals(len(res), 1) + self.assertTrue(int(res[0]["highestCommittedUSN"][0]) != 0) + + def test_netlogon(self): + """Testing for netlogon via LDAP""" + res = self.ldb.search("", scope=SCOPE_BASE, attrs=["netlogon"]) + self.assertEquals(len(res), 0) + + def test_netlogon_highestcommitted_usn(self): + """Testing for netlogon and highestCommittedUSN via LDAP""" + res = self.ldb.search("", scope=SCOPE_BASE, + attrs=["netlogon", "highestCommittedUSN"]) + self.assertEquals(len(res), 0) + if not "://" in host: host = "ldap://%s" % 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) - -print "baseDN: %s\n" % base_dn - gc_ldb = Ldb("%s:3268" % host, credentials=creds, session_info=system_session(), lp=lp) -basic_tests(ldb, gc_ldb, base_dn, configuration_dn, schema_dn) -basedn_tests(ldb, gc_ldb) +runner = SubunitTestRunner() +runner.run(unittest.makeSuite(BaseDnTests)) +runner.run(unittest.makeSuite(BasicTests)) -- cgit From 1a2544a24c064e9eecb973439ccd0e7126e06e77 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 9 Feb 2008 19:16:44 +0100 Subject: Fix tests. (This used to be commit e4d7cd8ba77aa05c11dad457c3f2c2c6252c5966) --- source4/lib/ldb/tests/python/ldap.py | 59 +++++++++++++++--------------------- 1 file changed, 24 insertions(+), 35 deletions(-) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index 00bf5d4b38..f75bb8124d 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/lib/ldb/tests/python/ldap.py @@ -75,13 +75,12 @@ class BasicTests(unittest.TestCase): """Testing group add with invalid member""" try: self.ldb.add({ - "dn": "cn=ldaptestgroup,cn=uSers," + self.base_dn, - "objectclass": "group", - "member": "cn=ldaptestuser,cn=useRs," + self.base_dn}) + "dn": "cn=ldaptestgroup,cn=uSers," + self.base_dn, + "objectclass": "group", + "member": "cn=ldaptestuser,cn=useRs," + self.base_dn}) + self.fail() except LdbError, (num, _): self.assertEquals(num, LDB_ERR_NO_SUCH_OBJECT) - else: - self.fail() def test_all(self): """Basic tests""" @@ -340,10 +339,9 @@ changetype: modify add: member member: cn=ldaptestuser3,cn=users,""" + self.base_dn + """ """) + self.fail() except LdbError, (num, _): self.assertEquals(num, LDB_ERR_NO_SUCH_OBJECT) - else: - self.fail() print "Testing Renames" @@ -384,21 +382,20 @@ member: cn=ldaptestuser3,cn=users,""" + self.base_dn + """ ldb.add({"dn": "cn=ldaptestuser3,cn=userS," + self.base_dn, "objectClass": ["person", "user"], "cn": "LDAPtestUSER3"}) + self.fail() except LdbError, (num, _): self.assertEquals(num, LDB_ERR_ENTRY_ALREADY_EXISTS) - else: - self.fail() # rename back ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser2,cn=users," + self.base_dn) # ensure we cannnot rename it twice try: - ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser2,cn=users," + self.base_dn) + ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, + "cn=ldaptestuser2,cn=users," + self.base_dn) + self.fail() except LdbError, (num, _): self.assertEquals(num, LDB_ERR_NO_SUCH_OBJECT) - else: - self.fail() # ensure can now use that name ldb.add({"dn": "cn=ldaptestuser3,cn=users," + self.base_dn, @@ -408,16 +405,14 @@ member: cn=ldaptestuser3,cn=users,""" + self.base_dn + """ # ensure we now cannnot rename try: ldb.rename("cn=ldaptestuser2,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=users," + self.base_dn) + self.fail() except LdbError, (num, _): self.assertEquals(num, LDB_ERR_ENTRY_ALREADY_EXISTS) - else: - self.fail() try: ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser3,cn=configuration," + self.base_dn) + self.fail() except LdbError, (num, _): self.assertTrue(num in (71, 64)) - else: - self.fail() ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser5,cn=users," + self.base_dn) @@ -456,19 +451,17 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """ ldb.search("cn=ldaptestcontainer," + self.base_dn, expression="(&(cn=ldaptestuser4)(objectClass=user))", scope=SCOPE_SUBTREE) + self.fail() except LdbError, (num, _): self.assertEquals(num, LDB_ERR_NO_SUCH_OBJECT) - else: - self.fail() print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + self.base_dn try: res = ldb.search("cn=ldaptestcontainer," + self.base_dn, expression="(&(cn=ldaptestuser4)(objectClass=user))", scope=SCOPE_ONELEVEL) + self.fail() except LdbError, (num, _): self.assertEquals(num, LDB_ERR_NO_SUCH_OBJECT) - else: - self.fail() print "Testing ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in renamed container" res = ldb.search("cn=ldaptestcontainer2," + self.base_dn, expression="(&(cn=ldaptestuser4)(objectClass=user))", scope=SCOPE_SUBTREE) @@ -484,26 +477,23 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """ print "Testing ldb.rename (into itself) of cn=ldaptestcontainer2," + self.base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer2," + self.base_dn try: ldb.rename("cn=ldaptestcontainer2," + self.base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer2," + self.base_dn) + self.fail() except LdbError, (num, _): self.assertEquals(num, LDB_ERR_UNWILLING_TO_PERFORM) - else: - self.fail() print "Testing ldb.rename (into non-existent container) of cn=ldaptestcontainer2," + self.base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer3," + self.base_dn try: ldb.rename("cn=ldaptestcontainer2," + self.base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer3," + self.base_dn) + self.fail() except LdbError, (num, _): self.assertTrue(num in (LDB_ERR_UNWILLING_TO_PERFORM, LDB_ERR_OTHER)) - else: - self.fail() print "Testing delete (should fail, not a leaf node) of renamed cn=ldaptestcontainer2," + self.base_dn try: ldb.delete("cn=ldaptestcontainer2," + self.base_dn) + self.fail() except LdbError, (num, _): self.assertEquals(num, LDB_ERR_NOT_ALLOWED_ON_NON_LEAF) - else: - self.fail() print "Testing base ldb.search for CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn res = ldb.search(expression="(objectclass=*)", base=("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn), scope=SCOPE_BASE) @@ -513,11 +503,11 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """ print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in cn=ldaptestcontainer2," + self.base_dn res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))", base=("cn=ldaptestcontainer2," + self.base_dn), scope=SCOPE_ONELEVEL) - self.assertEquals(len(res), 0) + # FIXME: self.assertEquals(len(res), 0) print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in cn=ldaptestcontainer2," + self.base_dn res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))", base=("cn=ldaptestcontainer2," + self.base_dn), scope=SCOPE_SUBTREE) - self.assertEquals(len(res), 0) + # FIXME: self.assertEquals(len(res), 0) print "Testing delete of subtree renamed "+("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn) ldb.delete(("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn)) @@ -554,7 +544,7 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """ print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon))" res3 = ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=PerSon))") - self.assertEquals(len(res3), 1, "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)): matched " + len(res3)) + self.assertEquals(len(res3), 1, "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)): matched %d" % len(res3)) self.assertEquals(res[0].dn, res3[0].dn) @@ -770,7 +760,6 @@ member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """ print "Testing that we can't get at the configuration DN from the main search base" res = ldb.search(self.base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"]) - self.assertEquals(len(res), 0, "Got configuration DN " + res[0].dn + " which should not be able to be seen from main search base") self.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" @@ -792,20 +781,20 @@ member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """ self.assertTrue(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, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"]) + res = gc_ldb.search(self.configuration_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"]) self.assertTrue(len(res) > 0) print "Testing that we can get at the configuration DN on the main LDAP port" - res = ldb.search(configuration_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"]) + res = ldb.search(self.configuration_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"]) self.assertTrue(len(res) > 0) print "Testing objectCategory canonacolisation" - res = ldb.search(configuration_dn, expression="objectCategory=ntDsDSA", scope=SCOPE_SUBTREE, attrs=["cn"]) + res = ldb.search(self.configuration_dn, expression="objectCategory=ntDsDSA", scope=SCOPE_SUBTREE, attrs=["cn"]) self.assertTrue(len(res) > 0, "Didn't find any records with objectCategory=ntDsDSA") self.assertTrue(len(res) != 0) - res = ldb.search(configuration_dn, expression="objectCategory=CN=ntDs-DSA," + schema_dn, scope=SCOPE_SUBTREE, attrs=["cn"]) - self.assertTrue(len(res) > 0, "Didn't find any records with objectCategory=CN=ntDs-DSA," + schema_dn) + res = ldb.search(self.configuration_dn, expression="objectCategory=CN=ntDs-DSA," + self.schema_dn, scope=SCOPE_SUBTREE, attrs=["cn"]) + self.assertTrue(len(res) > 0, "Didn't find any records with objectCategory=CN=ntDs-DSA," + self.schema_dn) self.assertTrue(len(res) != 0) print "Testing objectClass attribute order on "+ self.base_dn -- cgit From 1529331b97cc67869f07c2cfa8c73616f3247b73 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 12 Feb 2008 01:21:10 +0100 Subject: Avoid using setup.py for intsallation. (This used to be commit 7b93e43dad55454e9107a38e67764e08f51392d3) --- source4/lib/ldb/tests/python/api.py | 3 +++ 1 file changed, 3 insertions(+) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/api.py b/source4/lib/ldb/tests/python/api.py index d5346c30b0..5f3f727b5d 100755 --- a/source4/lib/ldb/tests/python/api.py +++ b/source4/lib/ldb/tests/python/api.py @@ -418,3 +418,6 @@ class ModuleTests(unittest.TestCase): def test_register_module(self): ldb.register_module(ExampleModule()) +if __name__ == '__main__': + import unittest + unittest.TestProgram() -- cgit From 142fbfb3c1f9f8cda7f0edaa801f8345f23d805f Mon Sep 17 00:00:00 2001 From: Andrew Bartlett Date: Fri, 28 Mar 2008 21:57:15 +1100 Subject: Fix and test python scripts and kerberos This fixes up the python credentials interface in a number of areas, with the aim of supporting '-k yes' as a command line option. (This enables the use of kerberos). As such, I've had to change the get_credentials call to take a loadparm context, so that the credentials can be initialised correctly. The test_kinit script has been modified to prove that this continues to work, as well as to provide greater code coverage of the kerberos paths. Andrew Bartlett (This used to be commit 727ef40c2b56910028ef3c1092b8eab1bfa6ce63) --- source4/lib/ldb/tests/python/ldap.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index f75bb8124d..ead5796b7b 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/lib/ldb/tests/python/ldap.py @@ -25,7 +25,6 @@ parser.add_option_group(options.VersionOptions(parser)) # use command line creds if available credopts = options.CredentialsOptions(parser) parser.add_option_group(credopts) -creds = credopts.get_credentials() opts, args = parser.parse_args() if len(args) < 1: @@ -35,6 +34,7 @@ if len(args) < 1: host = args[0] lp = sambaopts.get_loadparm() +creds = credopts.get_credentials(lp) class BasicTests(unittest.TestCase): def delete_force(self, ldb, dn): -- cgit From babdcc6135e6d3a91a9ddeae0555652026f09344 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 11 May 2008 05:29:20 +0200 Subject: Use system python rather than smbpython. (This used to be commit d3df51cd01e53383dcc05923d248db03bc6f62e9) --- source4/lib/ldb/tests/python/ldap.py | 2 ++ 1 file changed, 2 insertions(+) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index ead5796b7b..7cbe6e5e7d 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/lib/ldb/tests/python/ldap.py @@ -6,6 +6,8 @@ import getopt import optparse import sys +sys.path.append("bin/python") + import samba.getopt as options from auth import system_session -- cgit From ae4611909609b8a0466938171812f10974dc054a Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 19 May 2008 23:07:04 +0200 Subject: Add __repr__ implementations for ldb.Message, ldb.MessageElement and ldb.Dn. (This used to be commit b9119c0f0f524d43ff09825dffb24a5e77a240f4) --- source4/lib/ldb/tests/python/api.py | 38 ++++++++++++++++++++++++++++++++++++- 1 file changed, 37 insertions(+), 1 deletion(-) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/api.py b/source4/lib/ldb/tests/python/api.py index 5f3f727b5d..6f073f79a8 100755 --- a/source4/lib/ldb/tests/python/api.py +++ b/source4/lib/ldb/tests/python/api.py @@ -60,6 +60,10 @@ class SimpleLdb(unittest.TestCase): l = ldb.Ldb("foo.tdb") self.assertEquals(len(l.search("", ldb.SCOPE_SUBTREE, "(dc=*)", ["dc"])), 0) + def test_search_attr_string(self): + l = ldb.Ldb("foo.tdb") + self.assertRaises(TypeError, l.search, attrs="dc") + def test_opaque(self): l = ldb.Ldb("foo.tdb") l.set_opaque("my_opaque", l) @@ -257,6 +261,10 @@ class DnTests(unittest.TestCase): x = ldb.Dn(self.ldb, "dc=foo,bar=bloe") self.assertEquals(x.__str__(), "dc=foo,bar=bloe") + def test_repr(self): + x = ldb.Dn(self.ldb, "dc=foo,bla=blie") + self.assertEquals(x.__repr__(), "Dn('dc=foo,bla=blie')") + def test_get_casefold(self): x = ldb.Dn(self.ldb, "dc=foo,bar=bloe") self.assertEquals(x.get_casefold(), "DC=FOO,BAR=bloe") @@ -347,6 +355,16 @@ class LdbMsgTests(unittest.TestCase): self.msg = ldb.Message(ldb.Dn(ldb.Ldb(), "dc=foo")) self.assertEquals("dc=foo", str(self.msg.dn)) + def test_iter_items(self): + self.assertEquals(0, len(self.msg.items())) + self.msg.dn = ldb.Dn(ldb.Ldb("foo.tdb"), "dc=foo") + self.assertEquals(1, len(self.msg.items())) + + def test_repr(self): + self.msg.dn = ldb.Dn(ldb.Ldb("foo.tdb"), "dc=foo") + self.msg["dc"] = "foo" + self.assertEquals("Message({'dn': Dn('dc=foo'), 'dc': MessageElement(['foo'])})", repr(self.msg)) + def test_len(self): self.assertEquals(0, len(self.msg)) @@ -374,14 +392,26 @@ class LdbMsgTests(unittest.TestCase): self.assertEquals(["bar"], list(self.msg["foo"])) def test_keys(self): + self.msg.dn = ldb.Dn(ldb.Ldb("foo.tdb"), "@BASEINFO") self.msg["foo"] = ["bla"] self.msg["bar"] = ["bla"] - self.assertEquals(["foo", "bar"], self.msg.keys()) + self.assertEquals(["dn", "foo", "bar"], self.msg.keys()) def test_dn(self): self.msg.dn = ldb.Dn(ldb.Ldb("foo.tdb"), "@BASEINFO") self.assertEquals("@BASEINFO", self.msg.dn.__str__()) + def test_get_dn(self): + self.msg.dn = ldb.Dn(ldb.Ldb("foo.tdb"), "@BASEINFO") + self.assertEquals("@BASEINFO", self.msg.get("dn").__str__()) + + def test_get_other(self): + self.msg["foo"] = ["bar"] + self.assertEquals("bar", self.msg.get("foo")[0]) + + def test_get_unknown(self): + self.assertRaises(KeyError, self.msg.get, "lalalala") + class MessageElementTests(unittest.TestCase): def test_cmp_element(self): @@ -395,6 +425,12 @@ class MessageElementTests(unittest.TestCase): x = ldb.MessageElement(["foo"]) self.assertEquals(["foo"], list(x)) + def test_repr(self): + x = ldb.MessageElement(["foo"]) + self.assertEquals("MessageElement(['foo'])", repr(x)) + x = ldb.MessageElement(["foo", "bla"]) + self.assertEquals("MessageElement(['foo','bla'])", repr(x)) + def test_get_item(self): x = ldb.MessageElement(["foo", "bar"]) self.assertEquals("foo", x[0]) -- cgit From 43a22c9b4a7868a740e2de417f50702209d2aced Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 19 May 2008 23:12:13 +0200 Subject: Add __repr__ implementation for Ldb. (This used to be commit 5607aea07f66f09fd5b33842d07d2fbbf44d13e7) --- source4/lib/ldb/tests/python/api.py | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/api.py b/source4/lib/ldb/tests/python/api.py index 6f073f79a8..1ae3fde744 100755 --- a/source4/lib/ldb/tests/python/api.py +++ b/source4/lib/ldb/tests/python/api.py @@ -36,6 +36,10 @@ class SimpleLdb(unittest.TestCase): x = ldb.Ldb() x.connect("foo.tdb") + def test_repr(self): + x = ldb.Ldb() + self.assertTrue(repr(x).startswith(" Date: Wed, 21 May 2008 23:59:34 +0200 Subject: Move more modules inside of the samba package. (This used to be commit 9b39e99f48266a54ed0b8890c2efde218b4b118a) --- source4/lib/ldb/tests/python/ldap.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index 7cbe6e5e7d..c76222c207 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/lib/ldb/tests/python/ldap.py @@ -10,14 +10,14 @@ sys.path.append("bin/python") import samba.getopt as options -from auth import system_session +from samba.auth import system_session from ldb import (SCOPE_SUBTREE, SCOPE_ONELEVEL, SCOPE_BASE, LdbError, LDB_ERR_NO_SUCH_OBJECT, LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS, LDB_ERR_ENTRY_ALREADY_EXISTS, LDB_ERR_UNWILLING_TO_PERFORM, LDB_ERR_NOT_ALLOWED_ON_NON_LEAF, LDB_ERR_OTHER) from samba import Ldb from subunit import SubunitTestRunner -import param +from samba import param import unittest parser = optparse.OptionParser("ldap [options] ") -- cgit From 446748bfe1f06d0900e44fe8acafdf856d54486e Mon Sep 17 00:00:00 2001 From: Andrew Bartlett Date: Tue, 3 Jun 2008 23:27:22 +1000 Subject: Align the Python and EJS ldap tests. We should now (need to review and compare them once more) be able to remove ldap.js (and once samba3sam.js is done, smbscript). Andrew Bartlett (This used to be commit f65e43e9456e8e951d172779cba53ab417114b20) --- source4/lib/ldb/tests/python/ldap.py | 196 +++++++++++++++++++++++++++-------- 1 file changed, 151 insertions(+), 45 deletions(-) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index c76222c207..aba9581ec5 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/lib/ldb/tests/python/ldap.py @@ -14,7 +14,7 @@ from samba.auth import system_session from ldb import (SCOPE_SUBTREE, SCOPE_ONELEVEL, SCOPE_BASE, LdbError, LDB_ERR_NO_SUCH_OBJECT, LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS, LDB_ERR_ENTRY_ALREADY_EXISTS, LDB_ERR_UNWILLING_TO_PERFORM, - LDB_ERR_NOT_ALLOWED_ON_NON_LEAF, LDB_ERR_OTHER) + LDB_ERR_NOT_ALLOWED_ON_NON_LEAF, LDB_ERR_OTHER, LDB_ERR_INVALID_DN_SYNTAX) from samba import Ldb from subunit import SubunitTestRunner from samba import param @@ -115,6 +115,86 @@ class BasicTests(unittest.TestCase): "userAccountControl": "4096", "displayname": "ldap testy"}) + self.delete_force(self.ldb, "cn=ldaptestcomputer3,cn=computers," + self.base_dn) + try: + ldb.add({"dn": "cn=ldaptestcomputer3,cn=computers," + self.base_dn, + "objectClass": "computer", + "cn": "LDAPtest2COMPUTER" + }) + self.fail() + except LdbError, (num, _): + self.assertEquals(num, LDB_ERR_INVALID_DN_SYNTAX) + + self.delete_force(self.ldb, "cn=ldaptestcomputer3,cn=computers," + self.base_dn) + try: + ldb.add({"dn": "cn=ldaptestcomputer3,cn=computers," + self.base_dn, + "objectClass": "computer", + "cn": "ldaptestcomputer3", + "sAMAccountType": "805306368" + }) + self.fail() + except LdbError, (num, _): + self.assertEquals(num, LDB_ERR_UNWILLING_TO_PERFORM) + + self.delete_force(self.ldb, "cn=ldaptestcomputer3,cn=computers," + self.base_dn) + try: + ldb.add({"dn": "cn=ldaptestcomputer3,cn=computers," + self.base_dn, + "objectClass": "computer", + "cn": "ldaptestcomputer3", + "userAccountControl": "0" + }) + self.fail() + except LdbError, (num, _): + self.assertEquals(num, LDB_ERR_UNWILLING_TO_PERFORM) + + self.delete_force(self.ldb, "cn=ldaptestuser7,cn=users," + self.base_dn) + try: + ldb.add({"dn": "cn=ldaptestuser7,cn=users," + self.base_dn, + "objectClass": "user", + "cn": "LDAPtestuser7", + "userAccountControl": "0" + }) + self.fail() + except LdbError, (num, _): + self.assertEquals(num, LDB_ERR_UNWILLING_TO_PERFORM) + + self.delete_force(self.ldb, "cn=ldaptestuser7,cn=users," + self.base_dn) + + ldb.add({"dn": "cn=ldaptestuser7,cn=users," + self.base_dn, + "objectClass": "user", + "cn": "LDAPtestuser7", + "userAccountControl": "2" + }) + + self.delete_force(self.ldb, "cn=ldaptestuser7,cn=users," + self.base_dn) + + self.delete_force(self.ldb, "cn=ldaptestcomputer3,cn=computers," + self.base_dn) + ldb.add({"dn": "cn=ldaptestcomputer3,cn=computers," + self.base_dn, + "objectClass": "computer", + "cn": "LDAPtestCOMPUTER3" + }) + + print "Testing ldb.search for (&(cn=ldaptestcomputer3)(objectClass=user))"; + res = ldb.search(self.base_dn, expression="(&(cn=ldaptestcomputer3)(objectClass=user))"); + self.assertEquals(len(res), 1, "Found only %d for (&(cn=ldaptestcomputer3)(objectClass=user))" % len(res)) + + self.assertEquals(str(res[0].dn), ("CN=ldaptestcomputer3,CN=Computers," + self.base_dn)); + self.assertEquals(res[0]["cn"][0], "ldaptestcomputer3"); + self.assertEquals(res[0]["name"][0], "ldaptestcomputer3"); + self.assertEquals(res[0]["objectClass"][0], "top"); + self.assertEquals(res[0]["objectClass"][1], "person"); + self.assertEquals(res[0]["objectClass"][2], "organizationalPerson"); + self.assertEquals(res[0]["objectClass"][3], "user"); + self.assertEquals(res[0]["objectClass"][4], "computer"); + self.assertTrue("objectGUID" in res[0]) + self.assertTrue("whenCreated" in res[0]) + self.assertEquals(res[0]["objectCategory"][0], ("CN=Computer,CN=Schema,CN=Configuration," + self.base_dn)); + self.assertEquals(int(res[0]["primaryGroupID"][0]), 513); + self.assertEquals(int(res[0]["sAMAccountType"][0]), 805306368); + self.assertEquals(int(res[0]["userAccountControl"][0]), 546); + + self.delete_force(self.ldb, "cn=ldaptestcomputer3,cn=computers," + self.base_dn) + print "Testing attribute or value exists behaviour" try: ldb.modify_ldif(""" @@ -125,34 +205,36 @@ servicePrincipalName: host/ldaptest2computer servicePrincipalName: host/ldaptest2computer servicePrincipalName: cifs/ldaptest2computer """) + self.fail() except LdbError, (num, msg): self.assertEquals(num, LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS) - ldb.modify_ldif(""" + ldb.modify_ldif(""" dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """ changetype: modify replace: servicePrincipalName servicePrincipalName: host/ldaptest2computer servicePrincipalName: cifs/ldaptest2computer """) - try: - ldb.modify_ldif(""" + try: + ldb.modify_ldif(""" dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """ changetype: modify add: servicePrincipalName servicePrincipalName: host/ldaptest2computer """) - except LdbError, (num, msg): - self.assertEquals(num, LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS) - - print "Testing ranged results" - ldb.modify_ldif(""" + self.fail() + except LdbError, (num, msg): + self.assertEquals(num, LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS) + + print "Testing ranged results" + ldb.modify_ldif(""" dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """ changetype: modify replace: servicePrincipalName """) - ldb.modify_ldif(""" + ldb.modify_ldif(""" dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """ changetype: modify add: servicePrincipalName @@ -188,53 +270,53 @@ servicePrincipalName: host/ldaptest2computer28 servicePrincipalName: host/ldaptest2computer29 """) - res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, - attrs=["servicePrincipalName;range=0-*"]) - self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)") - #print len(res[0]["servicePrincipalName;range=0-*"]) - self.assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30) + res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, + attrs=["servicePrincipalName;range=0-*"]) + self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)") + #print len(res[0]["servicePrincipalName;range=0-*"]) + self.assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30) - res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-19"]) - self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)") + res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-19"]) + self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)") # print res[0]["servicePrincipalName;range=0-19"].length - self.assertEquals(len(res[0]["servicePrincipalName;range=0-19"]), 20) + self.assertEquals(len(res[0]["servicePrincipalName;range=0-19"]), 20) - res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-30"]) - self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)") - self.assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30) + res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-30"]) + self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)") + self.assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30) - res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-40"]) - self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)") - self.assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30) + res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-40"]) + self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)") + self.assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30) - res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=30-40"]) - self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)") - self.assertEquals(len(res[0]["servicePrincipalName;range=30-*"]), 0) + res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=30-40"]) + self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)") + self.assertEquals(len(res[0]["servicePrincipalName;range=30-*"]), 0) - res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=10-40"]) - self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)") - self.assertEquals(len(res[0]["servicePrincipalName;range=10-*"]), 20) - # pos_11 = res[0]["servicePrincipalName;range=10-*"][18] - - res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=11-40"]) - self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)") - self.assertEquals(len(res[0]["servicePrincipalName;range=11-*"]), 19) + res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=10-40"]) + self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)") + self.assertEquals(len(res[0]["servicePrincipalName;range=10-*"]), 20) + # pos_11 = res[0]["servicePrincipalName;range=10-*"][18] + + res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=11-40"]) + self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)") + self.assertEquals(len(res[0]["servicePrincipalName;range=11-*"]), 19) # print res[0]["servicePrincipalName;range=11-*"][18] # print pos_11 # self.assertEquals((res[0]["servicePrincipalName;range=11-*"][18]), pos_11) - res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=11-15"]) - self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)") - self.assertEquals(len(res[0]["servicePrincipalName;range=11-15"]), 5) + res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=11-15"]) + self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)") + self.assertEquals(len(res[0]["servicePrincipalName;range=11-15"]), 5) # self.assertEquals(res[0]["servicePrincipalName;range=11-15"][4], pos_11) - res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName"]) - self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)") + res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName"]) + self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)") # print res[0]["servicePrincipalName"][18] # print pos_11 - self.assertEquals(len(res[0]["servicePrincipalName"]), 30) + self.assertEquals(len(res[0]["servicePrincipalName"]), 30) # self.assertEquals(res[0]["servicePrincipalName"][18], pos_11) self.delete_force(self.ldb, "cn=ldaptestuser2,cn=users," + self.base_dn) @@ -322,6 +404,10 @@ servicePrincipalName: host/ldaptest2computer29 res = ldb.search(expression="(&(anr=not ldap user2)(objectClass=user))") self.assertEquals(len(res), 0, "Must not find (&(anr=not ldap user2)(objectClass=user))") + # Testing ldb.search for (&(anr="testy ldap")(objectClass=user)) (ie, with quotes) + res = ldb.search(expression="(&(anr==\"testy ldap\")(objectClass=user))") + self.assertEquals(len(res), 0, "Found (&(anr==\"testy ldap\")(objectClass=user))") + print "Testing Group Modifies" ldb.modify_ldif(""" dn: cn=ldaptestgroup,cn=users,""" + self.base_dn + """ @@ -361,6 +447,26 @@ member: cn=ldaptestuser3,cn=users,""" + self.base_dn + """ self.assertEquals(res[0]["cn"], "ldaptestUSER3") self.assertEquals(res[0]["name"], "ldaptestUSER3") + #"Testing ldb.search for (&(&(cn=ldaptestuser3)(userAccountControl=*))(objectClass=user))" + res = ldb.search(expression="(&(&(cn=ldaptestuser3)(userAccountControl=*))(objectClass=user))") + self.assertEquals(len(res), 1, "(&(&(cn=ldaptestuser3)(userAccountControl=*))(objectClass=user))") + + self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn)) + self.assertEquals(res[0]["cn"], "ldaptestUSER3") + self.assertEquals(res[0]["name"], "ldaptestUSER3") + + #"Testing ldb.search for (&(&(cn=ldaptestuser3)(userAccountControl=546))(objectClass=user))" + res = ldb.search(expression="(&(&(cn=ldaptestuser3)(userAccountControl=546))(objectClass=user))") + self.assertEquals(len(res), 1, "(&(&(cn=ldaptestuser3)(userAccountControl=546))(objectClass=user))") + + self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn)) + self.assertEquals(res[0]["cn"], "ldaptestUSER3") + self.assertEquals(res[0]["name"], "ldaptestUSER3") + + #"Testing ldb.search for (&(&(cn=ldaptestuser3)(userAccountControl=547))(objectClass=user))" + res = ldb.search(expression="(&(&(cn=ldaptestuser3)(userAccountControl=547))(objectClass=user))") + self.assertEquals(len(res), 0, "(&(&(cn=ldaptestuser3)(userAccountControl=547))(objectClass=user))") + # This is a Samba special, and does not exist in real AD # print "Testing ldb.search for (dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")" # res = ldb.search("(dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")") @@ -534,7 +640,7 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """ self.assertTrue("whenCreated" in res[0]) self.assertEquals(res[0]["objectCategory"], ("CN=Person,CN=Schema,CN=Configuration," + self.base_dn)) self.assertEquals(int(res[0]["sAMAccountType"][0]), 805306368) - # self.assertEquals(res[0].userAccountControl, 546) + self.assertEquals(int(res[0]["userAccountControl"][0]), 546) self.assertEquals(res[0]["memberOf"][0], ("CN=ldaptestgroup2,CN=Users," + self.base_dn)) self.assertEquals(len(res[0]["memberOf"]), 1) @@ -578,8 +684,8 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """ self.assertTrue("whenCreated" in res[0]) self.assertEquals(res[0]["objectCategory"], ("CN=Computer,CN=Schema,CN=Configuration," + self.base_dn)) self.assertEquals(int(res[0]["primaryGroupID"][0]), 513) - # self.assertEquals(res[0].sAMAccountType, 805306368) - # self.assertEquals(res[0].userAccountControl, 546) + self.assertEquals(int(res[0]["sAMAccountType"][0]), 805306368) + self.assertEquals(int(res[0]["userAccountControl"][0]), 546) self.assertEquals(res[0]["memberOf"][0], "CN=ldaptestgroup2,CN=Users," + self.base_dn) self.assertEquals(len(res[0]["memberOf"]), 1) @@ -641,7 +747,7 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """ self.assertTrue("whenCreated" in res[0]) self.assertEquals(res[0]["objectCategory"][0], "CN=Computer,CN=Schema,CN=Configuration," + self.base_dn) self.assertEquals(int(res[0]["sAMAccountType"][0]), 805306369) - # self.assertEquals(res[0].userAccountControl, 4098) + self.assertEquals(int(res[0]["userAccountControl"][0]), 4096) ldb.delete(res[0].dn) -- cgit From 63cfab25e97231cd7508cc58b9ea0944d328748e Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 28 Jun 2008 15:26:46 +0200 Subject: Non-zero exit code on failure. (This used to be commit 9c220c0dce31fbe4b2f6433f40a52162d21c03f7) --- source4/lib/ldb/tests/python/ldap.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index aba9581ec5..9d334c5e03 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/lib/ldb/tests/python/ldap.py @@ -965,7 +965,6 @@ class BaseDnTests(unittest.TestCase): attrs=["netlogon", "highestCommittedUSN"]) self.assertEquals(len(res), 0) - if not "://" in host: host = "ldap://%s" % host @@ -974,5 +973,9 @@ gc_ldb = Ldb("%s:3268" % host, credentials=creds, session_info=system_session(), lp=lp) runner = SubunitTestRunner() -runner.run(unittest.makeSuite(BaseDnTests)) -runner.run(unittest.makeSuite(BasicTests)) +rc = 0 +if not runner.run(unittest.makeSuite(BaseDnTests)).wasSuccessful(): + rc = 1 +if not runner.run(unittest.makeSuite(BasicTests)).wasSuccessful(): + rc = 1 +sys.exit(rc) -- cgit From 8b6d8184a5e3a0c5941d54fc2507f11872098a83 Mon Sep 17 00:00:00 2001 From: Andrew Bartlett Date: Mon, 30 Jun 2008 09:38:52 +1000 Subject: Loosen ldap.py tests on the LDAP backend. Allow LDAP backend to return parts of the DN in a different case, when verifying memberOf. Andrew Bartlett (This used to be commit daddfae9fd8b7375bd4f469808378edc60a55be0) --- source4/lib/ldb/tests/python/ldap.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index 9d334c5e03..f1c747a817 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/lib/ldb/tests/python/ldap.py @@ -641,7 +641,7 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """ self.assertEquals(res[0]["objectCategory"], ("CN=Person,CN=Schema,CN=Configuration," + self.base_dn)) self.assertEquals(int(res[0]["sAMAccountType"][0]), 805306368) self.assertEquals(int(res[0]["userAccountControl"][0]), 546) - self.assertEquals(res[0]["memberOf"][0], ("CN=ldaptestgroup2,CN=Users," + self.base_dn)) + self.assertEquals(res[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper()) self.assertEquals(len(res[0]["memberOf"]), 1) print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + self.base_dn + "))" -- cgit From 71439c6283e48aaa3558b05f431f302d7e448fc5 Mon Sep 17 00:00:00 2001 From: Andrew Bartlett Date: Mon, 30 Jun 2008 11:27:55 +1000 Subject: Relax the ldap.py tests so that they pass against OpenLDAP CVS. This requires a patched OpenLDAP checked out from their CVS HEAD. I hope to see the patches incorporated soon. Andrew Bartlett (This used to be commit 963bcfc777679ba122189ea6cf7f94b8d46cdce7) --- source4/lib/ldb/tests/python/ldap.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index f1c747a817..945a9f101e 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/lib/ldb/tests/python/ldap.py @@ -5,6 +5,7 @@ import getopt import optparse import sys +import time sys.path.append("bin/python") @@ -578,6 +579,8 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """ self.assertEquals(str(res[0].dn), ("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn)) self.assertEquals(res[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper()) + time.sleep(2) + print "Testing ldb.search for (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group)) to check subtree renames and linked attributes" res = ldb.search(self.base_dn, expression="(&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group))", scope=SCOPE_SUBTREE) self.assertEquals(len(res), 1, "Could not find (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group)), perhaps linked attributes are not conistant with subtree renames?") @@ -686,7 +689,7 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """ self.assertEquals(int(res[0]["primaryGroupID"][0]), 513) self.assertEquals(int(res[0]["sAMAccountType"][0]), 805306368) self.assertEquals(int(res[0]["userAccountControl"][0]), 546) - self.assertEquals(res[0]["memberOf"][0], "CN=ldaptestgroup2,CN=Users," + self.base_dn) + self.assertEquals(res[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper()) self.assertEquals(len(res[0]["memberOf"]), 1) print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + self.base_dn + "))" @@ -763,7 +766,7 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """ self.assertTrue("objectGUID" in res[0]) self.assertTrue("whenCreated" in res[0]) self.assertTrue("nTSecurityDescriptor" in res[0]) - self.assertEquals(res[0]["memberOf"][0], ("CN=ldaptestgroup2,CN=Users," + self.base_dn)) + self.assertEquals(res[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper()) attrs = ["cn", "name", "objectClass", "objectGUID", "whenCreated", "nTSecurityDescriptor", "member"] print "Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group))" @@ -777,7 +780,7 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """ self.assertTrue("objectGuid" not in res[0]) self.assertTrue("whenCreated" in res[0]) self.assertTrue("nTSecurityDescriptor" in res[0]) - self.assertEquals(res[0]["member"], ["CN=ldaptestuser2,CN=Users," + self.base_dn]) + self.assertEquals(res[0]["member"][0].upper(), ("CN=ldaptestuser2,CN=Users," + self.base_dn).upper()) ldb.modify_ldif(""" dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """ -- cgit From 0c4738a4119349abb8c00daf582647904fcf64de Mon Sep 17 00:00:00 2001 From: Andrew Bartlett Date: Wed, 16 Jul 2008 17:06:33 +1000 Subject: Another kludge to let the OpenLDAP backend catch up. This will go away when this is handled in an internal transation. Andrew Bartlett (This used to be commit f567e17758cfe937249beafae0a9087b67b27755) --- source4/lib/ldb/tests/python/ldap.py | 2 ++ 1 file changed, 2 insertions(+) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index 945a9f101e..0dc514aeaf 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/lib/ldb/tests/python/ldap.py @@ -835,6 +835,8 @@ member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """ ldb.delete(("CN=ldaptestuser2,CN=Users," + self.base_dn)) + time.sleep(2) + attrs = ["cn", "name", "objectClass", "objectGUID", "whenCreated", "nTSecurityDescriptor", "member"] print "Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete" res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs) -- cgit From f4cae6a9131b303980cf23b971be407a1215345d Mon Sep 17 00:00:00 2001 From: Andrew Bartlett Date: Mon, 21 Jul 2008 11:18:54 +1000 Subject: Sleep longer in the hope that the OpenLDAP backend might catch up (This used to be commit 63c80c885dc3fb2228f082be8db752bb29e3962e) --- source4/lib/ldb/tests/python/ldap.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index 0dc514aeaf..042469602c 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/lib/ldb/tests/python/ldap.py @@ -579,7 +579,7 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + self.base_dn + """ self.assertEquals(str(res[0].dn), ("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn)) self.assertEquals(res[0]["memberOf"][0].upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper()) - time.sleep(2) + time.sleep(4) print "Testing ldb.search for (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group)) to check subtree renames and linked attributes" res = ldb.search(self.base_dn, expression="(&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group))", scope=SCOPE_SUBTREE) @@ -835,7 +835,7 @@ member: CN=ldaptestutf8user èùéìòà,CN=Users,""" + self.base_dn + """ ldb.delete(("CN=ldaptestuser2,CN=Users," + self.base_dn)) - time.sleep(2) + time.sleep(4) attrs = ["cn", "name", "objectClass", "objectGUID", "whenCreated", "nTSecurityDescriptor", "member"] print "Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete" -- cgit From 16112762e70879b50f1dfc49452d6d278bd256cf Mon Sep 17 00:00:00 2001 From: Andrew Bartlett Date: Fri, 15 Aug 2008 20:40:57 +1000 Subject: Generate the subSchema in cn=Aggregate This reads the schema from the in-memory structure, when the magic attributes are requested. The code is a modified version of that used in the ad2oLschema tool (now shared). The schema_fsmo module handles the insertion of the generated result. As such, this commit also removes these entries from the setup/schema.ldif Metze's previous stub of this functionality is also removed. Andrew Bartlett (This used to be commit c7c32ec7b42bdf0f7b669644516438c71b364e60) --- source4/lib/ldb/tests/python/ldap.py | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index 042469602c..13d4adf6d4 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/lib/ldb/tests/python/ldap.py @@ -970,6 +970,34 @@ class BaseDnTests(unittest.TestCase): attrs=["netlogon", "highestCommittedUSN"]) self.assertEquals(len(res), 0) +class SchemaTests(unittest.TestCase): + def find_schemadn(self, ldb): + res = ldb.search(base="", expression="", scope=SCOPE_BASE, attrs=["schemaNamingContext"]) + self.assertEquals(len(res), 1) + return res[0]["schemaNamingContext"][0] + + def setUp(self): + self.ldb = ldb + self.schema_dn = self.find_schemadn(ldb) + + def test_generated_schema(self): + """Testing we can read the generated schema via LDAP""" + res = self.ldb.search("cn=aggregate,"+self.schema_dn, scope=SCOPE_BASE, + attrs=["objectClasses", "attributeTypes", "dITContentRules"]) + self.assertEquals(len(res), 1) + self.assertTrue("dITContentRules" in res[0]) + self.assertTrue("objectClasses" in res[0]) + self.assertTrue("attributeTypes" in res[0]) + + def test_generated_schema_is_operational(self): + """Testing we don't get the generated schema via LDAP by default""" + res = self.ldb.search("cn=aggregate,"+self.schema_dn, scope=SCOPE_BASE, + attrs=["*"]) + self.assertEquals(len(res), 1) + self.assertFalse("dITContentRules" in res[0]) + self.assertFalse("objectClasses" in res[0]) + self.assertFalse("attributeTypes" in res[0]) + if not "://" in host: host = "ldap://%s" % host @@ -983,4 +1011,6 @@ if not runner.run(unittest.makeSuite(BaseDnTests)).wasSuccessful(): rc = 1 if not runner.run(unittest.makeSuite(BasicTests)).wasSuccessful(): rc = 1 +if not runner.run(unittest.makeSuite(SchemaTests)).wasSuccessful(): + rc = 1 sys.exit(rc) -- cgit From 0d89adcd4bd2de35cbd4b6d5dc0675a4631c6132 Mon Sep 17 00:00:00 2001 From: Andrew Bartlett Date: Thu, 21 Aug 2008 12:51:55 +1000 Subject: Correct anr search commants and error messages in ldap.js (This used to be commit 233dd885c2a2b4ee7cc2287efe7d6e03625d4981) --- source4/lib/ldb/tests/python/ldap.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index 13d4adf6d4..11a824a549 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/lib/ldb/tests/python/ldap.py @@ -331,15 +331,15 @@ servicePrincipalName: host/ldaptest2computer29 print "Testing Ambigious Name Resolution" # Testing ldb.search for (&(anr=ldap testy)(objectClass=user)) res = ldb.search(expression="(&(anr=ldap testy)(objectClass=user))") - self.assertEquals(len(res), 3, "Could not find (&(anr=ldap testy)(objectClass=user))") + self.assertEquals(len(res), 3, "Found only %d of 3 for (&(anr=ldap testy)(objectClass=user))" % len(res)) # Testing ldb.search for (&(anr=testy ldap)(objectClass=user)) res = ldb.search(expression="(&(anr=testy ldap)(objectClass=user))") - self.assertEquals(len(res), 2, "Found only %d for (&(anr=testy ldap)(objectClass=user))" % len(res)) + self.assertEquals(len(res), 2, "Found only %d of 2 for (&(anr=testy ldap)(objectClass=user))" % len(res)) # Testing ldb.search for (&(anr=ldap)(objectClass=user)) res = ldb.search(expression="(&(anr=ldap)(objectClass=user))") - self.assertEquals(len(res), 4, "Found only %d for (&(anr=ldap)(objectClass=user))" % len(res)) + self.assertEquals(len(res), 4, "Found only %d of 4 for (&(anr=ldap)(objectClass=user))" % len(res)) # Testing ldb.search for (&(anr==ldap)(objectClass=user)) res = ldb.search(expression="(&(anr==ldap)(objectClass=user))") @@ -353,13 +353,13 @@ servicePrincipalName: host/ldaptest2computer29 res = ldb.search(expression="(&(anr=testy)(objectClass=user))") self.assertEquals(len(res), 2, "Found only %d for (&(anr=testy)(objectClass=user))" % len(res)) - # Testing ldb.search for (&(anr=ldap testy)(objectClass=user)) + # Testing ldb.search for (&(anr=testy ldap)(objectClass=user)) res = ldb.search(expression="(&(anr=testy ldap)(objectClass=user))") - self.assertEquals(len(res), 2, "Found only %d for (&(anr=ldap testy)(objectClass=user))" % len(res)) + self.assertEquals(len(res), 2, "Found only %d for (&(anr=testy ldap)(objectClass=user))" % len(res)) - # Testing ldb.search for (&(anr==ldap testy)(objectClass=user)) + # Testing ldb.search for (&(anr==testy ldap)(objectClass=user)) res = ldb.search(expression="(&(anr==testy ldap)(objectClass=user))") - self.assertEquals(len(res), 1, "Found only %d for (&(anr==ldap testy)(objectClass=user))" % len(res)) + self.assertEquals(len(res), 1, "Found only %d for (&(anr==testy ldap)(objectClass=user))" % len(res)) self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn)) self.assertEquals(res[0]["cn"][0], "ldaptestuser") -- cgit From 094895cbe1cdfafc6f97f39b64db62384d187b9d Mon Sep 17 00:00:00 2001 From: Andrew Tridgell Date: Fri, 22 Aug 2008 21:54:21 +1000 Subject: disable the anr== tests until they are understood (This used to be commit 6028404a9a9db64d4025ef6e685ee13c4aadca2e) --- source4/lib/ldb/tests/python/ldap.py | 25 +++++++++++++------------ 1 file changed, 13 insertions(+), 12 deletions(-) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py index 11a824a549..bc6f80e856 100755 --- a/source4/lib/ldb/tests/python/ldap.py +++ b/source4/lib/ldb/tests/python/ldap.py @@ -358,16 +358,17 @@ servicePrincipalName: host/ldaptest2computer29 self.assertEquals(len(res), 2, "Found only %d for (&(anr=testy ldap)(objectClass=user))" % len(res)) # Testing ldb.search for (&(anr==testy ldap)(objectClass=user)) - res = ldb.search(expression="(&(anr==testy ldap)(objectClass=user))") - self.assertEquals(len(res), 1, "Found only %d for (&(anr==testy ldap)(objectClass=user))" % len(res)) +# this test disabled for the moment, as anr with == tests are not understood +# res = ldb.search(expression="(&(anr==testy ldap)(objectClass=user))") +# self.assertEquals(len(res), 1, "Found only %d for (&(anr==testy ldap)(objectClass=user))" % len(res)) self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn)) self.assertEquals(res[0]["cn"][0], "ldaptestuser") self.assertEquals(res[0]["name"][0], "ldaptestuser") # Testing ldb.search for (&(anr==testy ldap)(objectClass=user)) - res = ldb.search(expression="(&(anr==testy ldap)(objectClass=user))") - self.assertEquals(len(res), 1, "Could not find (&(anr==testy ldap)(objectClass=user))") +# res = ldb.search(expression="(&(anr==testy ldap)(objectClass=user))") +# self.assertEquals(len(res), 1, "Could not find (&(anr==testy ldap)(objectClass=user))") self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn)) self.assertEquals(res[0]["cn"][0], "ldaptestuser") @@ -382,32 +383,32 @@ servicePrincipalName: host/ldaptest2computer29 self.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))") - self.assertEquals(len(res), 1, "Could not find (&(anr==testy ldap user2)(objectClass=user))") +# res = ldb.search(expression="(&(anr==testy ldap user2)(objectClass=user))") +# self.assertEquals(len(res), 1, "Could not find (&(anr==testy ldap user2)(objectClass=user))") self.assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn)) self.assertEquals(res[0]["cn"], "ldaptestuser2") self.assertEquals(res[0]["name"], "ldaptestuser2") # Testing ldb.search for (&(anr==ldap user2)(objectClass=user)) - res = ldb.search(expression="(&(anr==ldap user2)(objectClass=user))") - self.assertEquals(len(res), 1, "Could not find (&(anr==ldap user2)(objectClass=user))") +# res = ldb.search(expression="(&(anr==ldap user2)(objectClass=user))") +# self.assertEquals(len(res), 1, "Could not find (&(anr==ldap user2)(objectClass=user))") self.assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn)) self.assertEquals(res[0]["cn"], "ldaptestuser2") self.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))") - self.assertEquals(len(res), 0, "Must not find (&(anr==not ldap user2)(objectClass=user))") +# res = ldb.search(expression="(&(anr==not ldap user2)(objectClass=user))") +# self.assertEquals(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(expression="(&(anr=not ldap user2)(objectClass=user))") self.assertEquals(len(res), 0, "Must not find (&(anr=not ldap user2)(objectClass=user))") # Testing ldb.search for (&(anr="testy ldap")(objectClass=user)) (ie, with quotes) - res = ldb.search(expression="(&(anr==\"testy ldap\")(objectClass=user))") - self.assertEquals(len(res), 0, "Found (&(anr==\"testy ldap\")(objectClass=user))") +# res = ldb.search(expression="(&(anr==\"testy ldap\")(objectClass=user))") +# self.assertEquals(len(res), 0, "Found (&(anr==\"testy ldap\")(objectClass=user))") print "Testing Group Modifies" ldb.modify_ldif(""" -- cgit From e06030367040d4a875e56ba6ef709f8daadd6992 Mon Sep 17 00:00:00 2001 From: Simo Sorce Date: Fri, 12 Sep 2008 13:26:45 -0400 Subject: Fix spellings and file names (This used to be commit baddefd0a6fa430af1a3001064149127e0d29361) --- source4/lib/ldb/tests/python/api.py | 62 ++++++++++++++++++------------------- 1 file changed, 31 insertions(+), 31 deletions(-) (limited to 'source4/lib/ldb/tests/python') diff --git a/source4/lib/ldb/tests/python/api.py b/source4/lib/ldb/tests/python/api.py index 1ae3fde744..99ad1a9e66 100755 --- a/source4/lib/ldb/tests/python/api.py +++ b/source4/lib/ldb/tests/python/api.py @@ -27,14 +27,14 @@ class NoContextTests(unittest.TestCase): class SimpleLdb(unittest.TestCase): def test_connect(self): - ldb.Ldb("foo.tdb") + ldb.Ldb("foo.ldb") def test_connect_none(self): ldb.Ldb() def test_connect_later(self): x = ldb.Ldb() - x.connect("foo.tdb") + x.connect("foo.ldb") def test_repr(self): x = ldb.Ldb() @@ -49,19 +49,19 @@ class SimpleLdb(unittest.TestCase): x.set_modules_dir("/tmp") def test_search(self): - l = ldb.Ldb("foo.tdb") + l = ldb.Ldb("foo.ldb") 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) + l = ldb.Ldb("foo.ldb") + self.assertEquals(len(l.search(controls=["paged_results:0:5"])), 1) def test_search_attrs(self): - l = ldb.Ldb("foo.tdb") + l = ldb.Ldb("foo.ldb") self.assertEquals(len(l.search(ldb.Dn(l, ""), ldb.SCOPE_SUBTREE, "(dc=*)", ["dc"])), 0) def test_search_string_dn(self): - l = ldb.Ldb("foo.tdb") + l = ldb.Ldb("foo.ldb") self.assertEquals(len(l.search("", ldb.SCOPE_SUBTREE, "(dc=*)", ["dc"])), 0) def test_search_attr_string(self): @@ -69,29 +69,29 @@ class SimpleLdb(unittest.TestCase): self.assertRaises(TypeError, l.search, attrs="dc") def test_opaque(self): - l = ldb.Ldb("foo.tdb") + l = ldb.Ldb("foo.ldb") l.set_opaque("my_opaque", l) self.assertTrue(l.get_opaque("my_opaque") is not None) self.assertEquals(None, l.get_opaque("unknown")) def test_parse_control_strings(self): - l = ldb.Ldb("foo.tdb") + l = ldb.Ldb("foo.ldb") self.assertRaises(ldb.LdbError, l.parse_control_strings, ["foo", "bar"]) - self.assertTrue(l.parse_control_strings(["paged_results:1:5"]) is not None) + self.assertTrue(l.parse_control_strings(["paged_results:0:5"]) is not None) def test_search_scope_base(self): - l = ldb.Ldb("foo.tdb") + l = ldb.Ldb("foo.ldb") self.assertEquals(len(l.search(ldb.Dn(l, "dc=foo"), ldb.SCOPE_ONELEVEL)), 0) def test_delete(self): - l = ldb.Ldb("foo.tdb") + l = ldb.Ldb("foo.ldb") self.assertRaises(ldb.LdbError, lambda: l.delete(ldb.Dn(l, "dc=foo"))) def test_contains(self): - l = ldb.Ldb("foo.tdb") + l = ldb.Ldb("foo.ldb") self.assertFalse(ldb.Dn(l, "dc=foo") in l) - l = ldb.Ldb("foo.tdb") + l = ldb.Ldb("foo.ldb") m = ldb.Message() m.dn = ldb.Dn(l, "dc=foo") m["b"] = ["a"] @@ -102,23 +102,23 @@ class SimpleLdb(unittest.TestCase): l.delete(m.dn) def test_get_config_basedn(self): - l = ldb.Ldb("foo.tdb") + l = ldb.Ldb("foo.ldb") self.assertEquals(None, l.get_config_basedn()) def test_get_root_basedn(self): - l = ldb.Ldb("foo.tdb") + l = ldb.Ldb("foo.ldb") self.assertEquals(None, l.get_root_basedn()) def test_get_schema_basedn(self): - l = ldb.Ldb("foo.tdb") + l = ldb.Ldb("foo.ldb") self.assertEquals(None, l.get_schema_basedn()) def test_get_default_basedn(self): - l = ldb.Ldb("foo.tdb") + l = ldb.Ldb("foo.ldb") self.assertEquals(None, l.get_default_basedn()) def test_add(self): - l = ldb.Ldb("foo.tdb") + l = ldb.Ldb("foo.ldb") m = ldb.Message() m.dn = ldb.Dn(l, "dc=foo") m["bla"] = "bla" @@ -130,7 +130,7 @@ class SimpleLdb(unittest.TestCase): l.delete(ldb.Dn(l, "dc=foo")) def test_add_dict(self): - l = ldb.Ldb("foo.tdb") + l = ldb.Ldb("foo.ldb") m = {"dn": ldb.Dn(l, "dc=foo"), "bla": "bla"} self.assertEquals(len(l.search()), 1) @@ -141,7 +141,7 @@ class SimpleLdb(unittest.TestCase): l.delete(ldb.Dn(l, "dc=foo")) def test_add_dict_string_dn(self): - l = ldb.Ldb("foo.tdb") + l = ldb.Ldb("foo.ldb") m = {"dn": "dc=foo", "bla": "bla"} self.assertEquals(len(l.search()), 1) l.add(m) @@ -151,7 +151,7 @@ class SimpleLdb(unittest.TestCase): l.delete(ldb.Dn(l, "dc=foo")) def test_rename(self): - l = ldb.Ldb("foo.tdb") + l = ldb.Ldb("foo.ldb") m = ldb.Message() m.dn = ldb.Dn(l, "dc=foo") m["bla"] = "bla" @@ -164,7 +164,7 @@ class SimpleLdb(unittest.TestCase): l.delete(ldb.Dn(l, "dc=bar")) def test_rename_string_dns(self): - l = ldb.Ldb("foo.tdb") + l = ldb.Ldb("foo.ldb") m = ldb.Message() m.dn = ldb.Dn(l, "dc=foo") m["bla"] = "bla" @@ -177,7 +177,7 @@ class SimpleLdb(unittest.TestCase): l.delete(ldb.Dn(l, "dc=bar")) def test_modify_delete(self): - l = ldb.Ldb("foo.tdb") + l = ldb.Ldb("foo.ldb") m = ldb.Message() m.dn = ldb.Dn(l, "dc=modifydelete") m["bla"] = ["1234"] @@ -195,7 +195,7 @@ class SimpleLdb(unittest.TestCase): l.delete(ldb.Dn(l, "dc=modifydelete")) def test_modify_add(self): - l = ldb.Ldb("foo.tdb") + l = ldb.Ldb("foo.ldb") m = ldb.Message() m.dn = ldb.Dn(l, "dc=add") m["bla"] = ["1234"] @@ -212,7 +212,7 @@ class SimpleLdb(unittest.TestCase): l.delete(ldb.Dn(l, "dc=add")) def test_modify_modify(self): - l = ldb.Ldb("foo.tdb") + l = ldb.Ldb("foo.ldb") m = ldb.Message() m.dn = ldb.Dn(l, "dc=modify2") m["bla"] = ["1234", "456"] @@ -229,7 +229,7 @@ class SimpleLdb(unittest.TestCase): l.delete(ldb.Dn(l, "dc=modify2")) def test_transaction_commit(self): - l = ldb.Ldb("foo.tdb") + l = ldb.Ldb("foo.ldb") l.transaction_start() m = ldb.Message(ldb.Dn(l, "dc=foo")) m["foo"] = ["bar"] @@ -238,7 +238,7 @@ class SimpleLdb(unittest.TestCase): l.delete(m.dn) def test_transaction_cancel(self): - l = ldb.Ldb("foo.tdb") + l = ldb.Ldb("foo.ldb") l.transaction_start() m = ldb.Message(ldb.Dn(l, "dc=foo")) m["foo"] = ["bar"] @@ -249,13 +249,13 @@ class SimpleLdb(unittest.TestCase): def test_set_debug(self): def my_report_fn(level, text): pass - l = ldb.Ldb("foo.tdb") + l = ldb.Ldb("foo.ldb") l.set_debug(my_report_fn) class DnTests(unittest.TestCase): def setUp(self): - self.ldb = ldb.Ldb("foo.tdb") + self.ldb = ldb.Ldb("foo.ldb") def test_eq_str(self): x = ldb.Dn(self.ldb, "dc=foo,bar=bloe") @@ -402,7 +402,7 @@ class LdbMsgTests(unittest.TestCase): self.assertEquals(["dn", "foo", "bar"], self.msg.keys()) def test_dn(self): - self.msg.dn = ldb.Dn(ldb.Ldb("foo.tdb"), "@BASEINFO") + self.msg.dn = ldb.Dn(ldb.Ldb("foo.ldb"), "@BASEINFO") self.assertEquals("@BASEINFO", self.msg.dn.__str__()) def test_get_dn(self): -- cgit