2 # Simple tests for the ldb python bindings.
3 # Copyright (C) 2007 Jelmer Vernooij <jelmer@samba.org>
8 # Required for the standalone LDB build
9 sys.path.append("swig")
10 sys.path.append("build/lib.linux-i686-2.4")
14 class NoContextTests(unittest.TestCase):
15 def test_valid_attr_name(self):
16 self.assertTrue(ldb.valid_attr_name("foo"))
17 self.assertFalse(ldb.valid_attr_name("24foo"))
19 def test_timestring(self):
20 self.assertEquals("19700101000000.0Z", ldb.timestring(0))
21 self.assertEquals("20071119191012.0Z", ldb.timestring(1195499412))
23 def test_string_to_time(self):
24 self.assertEquals(0, ldb.string_to_time("19700101000000.0Z"))
25 self.assertEquals(1195499412, ldb.string_to_time("20071119191012.0Z"))
28 class SimpleLdb(unittest.TestCase):
29 def test_connect(self):
32 def test_connect_none(self):
35 def test_connect_later(self):
41 self.assertTrue(repr(x).startswith("<ldb connection"))
43 def test_set_create_perms(self):
45 x.set_create_perms(0600)
47 def test_set_modules_dir(self):
49 x.set_modules_dir("/tmp")
51 def test_search(self):
52 l = ldb.Ldb("foo.ldb")
53 self.assertEquals(len(l.search()), 1)
55 def test_search_controls(self):
56 l = ldb.Ldb("foo.ldb")
57 self.assertEquals(len(l.search(controls=["paged_results:0:5"])), 1)
59 def test_search_attrs(self):
60 l = ldb.Ldb("foo.ldb")
61 self.assertEquals(len(l.search(ldb.Dn(l, ""), ldb.SCOPE_SUBTREE, "(dc=*)", ["dc"])), 0)
63 def test_search_string_dn(self):
64 l = ldb.Ldb("foo.ldb")
65 self.assertEquals(len(l.search("", ldb.SCOPE_SUBTREE, "(dc=*)", ["dc"])), 0)
67 def test_search_attr_string(self):
68 l = ldb.Ldb("foo.tdb")
69 self.assertRaises(TypeError, l.search, attrs="dc")
71 def test_opaque(self):
72 l = ldb.Ldb("foo.ldb")
73 l.set_opaque("my_opaque", l)
74 self.assertTrue(l.get_opaque("my_opaque") is not None)
75 self.assertEquals(None, l.get_opaque("unknown"))
77 def test_parse_control_strings(self):
78 l = ldb.Ldb("foo.ldb")
79 self.assertRaises(ldb.LdbError, l.parse_control_strings, ["foo", "bar"])
80 self.assertTrue(l.parse_control_strings(["paged_results:0:5"]) is not None)
82 def test_search_scope_base(self):
83 l = ldb.Ldb("foo.ldb")
84 self.assertEquals(len(l.search(ldb.Dn(l, "dc=foo"),
85 ldb.SCOPE_ONELEVEL)), 0)
87 def test_delete(self):
88 l = ldb.Ldb("foo.ldb")
89 self.assertRaises(ldb.LdbError, lambda: l.delete(ldb.Dn(l, "dc=foo")))
91 def test_contains(self):
92 l = ldb.Ldb("foo.ldb")
93 self.assertFalse(ldb.Dn(l, "dc=foo") in l)
94 l = ldb.Ldb("foo.ldb")
96 m.dn = ldb.Dn(l, "dc=foo")
100 self.assertTrue(ldb.Dn(l, "dc=foo") in l)
104 def test_get_config_basedn(self):
105 l = ldb.Ldb("foo.ldb")
106 self.assertEquals(None, l.get_config_basedn())
108 def test_get_root_basedn(self):
109 l = ldb.Ldb("foo.ldb")
110 self.assertEquals(None, l.get_root_basedn())
112 def test_get_schema_basedn(self):
113 l = ldb.Ldb("foo.ldb")
114 self.assertEquals(None, l.get_schema_basedn())
116 def test_get_default_basedn(self):
117 l = ldb.Ldb("foo.ldb")
118 self.assertEquals(None, l.get_default_basedn())
121 l = ldb.Ldb("foo.ldb")
123 m.dn = ldb.Dn(l, "dc=foo")
125 self.assertEquals(len(l.search()), 1)
128 self.assertEquals(len(l.search()), 2)
130 l.delete(ldb.Dn(l, "dc=foo"))
132 def test_add_dict(self):
133 l = ldb.Ldb("foo.ldb")
134 m = {"dn": ldb.Dn(l, "dc=foo"),
136 self.assertEquals(len(l.search()), 1)
139 self.assertEquals(len(l.search()), 2)
141 l.delete(ldb.Dn(l, "dc=foo"))
143 def test_add_dict_string_dn(self):
144 l = ldb.Ldb("foo.ldb")
145 m = {"dn": "dc=foo", "bla": "bla"}
146 self.assertEquals(len(l.search()), 1)
149 self.assertEquals(len(l.search()), 2)
151 l.delete(ldb.Dn(l, "dc=foo"))
153 def test_rename(self):
154 l = ldb.Ldb("foo.ldb")
156 m.dn = ldb.Dn(l, "dc=foo")
158 self.assertEquals(len(l.search()), 1)
161 l.rename(ldb.Dn(l, "dc=foo"), ldb.Dn(l, "dc=bar"))
162 self.assertEquals(len(l.search()), 2)
164 l.delete(ldb.Dn(l, "dc=bar"))
166 def test_rename_string_dns(self):
167 l = ldb.Ldb("foo.ldb")
169 m.dn = ldb.Dn(l, "dc=foo")
171 self.assertEquals(len(l.search()), 1)
174 l.rename("dc=foo", "dc=bar")
175 self.assertEquals(len(l.search()), 2)
177 l.delete(ldb.Dn(l, "dc=bar"))
179 def test_modify_delete(self):
180 l = ldb.Ldb("foo.ldb")
182 m.dn = ldb.Dn(l, "dc=modifydelete")
185 rm = l.search(m.dn)[0]
186 self.assertEquals(["1234"], list(rm["bla"]))
189 m.dn = ldb.Dn(l, "dc=modifydelete")
190 m["bla"] = ldb.MessageElement([], ldb.CHANGETYPE_DELETE, "bla")
192 rm = l.search(m.dn)[0]
193 self.assertEquals(1, len(rm))
195 l.delete(ldb.Dn(l, "dc=modifydelete"))
197 def test_modify_add(self):
198 l = ldb.Ldb("foo.ldb")
200 m.dn = ldb.Dn(l, "dc=add")
205 m.dn = ldb.Dn(l, "dc=add")
206 m["bla"] = ldb.MessageElement(["456"], ldb.CHANGETYPE_ADD, "bla")
208 rm = l.search(m.dn)[0]
209 self.assertEquals(2, len(rm))
210 self.assertEquals(["1234", "456"], list(rm["bla"]))
212 l.delete(ldb.Dn(l, "dc=add"))
214 def test_modify_modify(self):
215 l = ldb.Ldb("foo.ldb")
217 m.dn = ldb.Dn(l, "dc=modify2")
218 m["bla"] = ["1234", "456"]
222 m.dn = ldb.Dn(l, "dc=modify2")
223 m["bla"] = ldb.MessageElement(["456"], ldb.CHANGETYPE_MODIFY, "bla")
225 rm = l.search(m.dn)[0]
226 self.assertEquals(2, len(rm))
227 self.assertEquals(["1234"], list(rm["bla"]))
229 l.delete(ldb.Dn(l, "dc=modify2"))
231 def test_transaction_commit(self):
232 l = ldb.Ldb("foo.ldb")
233 l.transaction_start()
234 m = ldb.Message(ldb.Dn(l, "dc=foo"))
237 l.transaction_commit()
240 def test_transaction_cancel(self):
241 l = ldb.Ldb("foo.ldb")
242 l.transaction_start()
243 m = ldb.Message(ldb.Dn(l, "dc=foo"))
246 l.transaction_cancel()
247 self.assertEquals(0, len(l.search(ldb.Dn(l, "dc=foo"))))
249 def test_set_debug(self):
250 def my_report_fn(level, text):
252 l = ldb.Ldb("foo.ldb")
253 l.set_debug(my_report_fn)
256 class DnTests(unittest.TestCase):
258 self.ldb = ldb.Ldb("foo.ldb")
260 def test_eq_str(self):
261 x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
262 self.assertEquals("dc=foo,bar=bloe", x)
265 x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
266 self.assertEquals(x.__str__(), "dc=foo,bar=bloe")
269 x = ldb.Dn(self.ldb, "dc=foo,bla=blie")
270 self.assertEquals(x.__repr__(), "Dn('dc=foo,bla=blie')")
272 def test_get_casefold(self):
273 x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
274 self.assertEquals(x.get_casefold(), "DC=FOO,BAR=bloe")
276 def test_validate(self):
277 x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
278 self.assertTrue(x.validate())
280 def test_parent(self):
281 x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
282 self.assertEquals("bar=bloe", x.parent().__str__())
284 def test_compare(self):
285 x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
286 y = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
287 self.assertEquals(x, y)
288 z = ldb.Dn(self.ldb, "dc=foo,bar=blie")
289 self.assertNotEquals(z, y)
291 def test_is_valid(self):
292 x = ldb.Dn(self.ldb, "dc=foo,dc=bloe")
293 self.assertTrue(x.is_valid())
294 x = ldb.Dn(self.ldb, "")
295 # is_valid()'s return values appears to be a side effect of
296 # some other ldb functions. yuck.
297 # self.assertFalse(x.is_valid())
299 def test_is_special(self):
300 x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
301 self.assertFalse(x.is_special())
302 x = ldb.Dn(self.ldb, "@FOOBAR")
303 self.assertTrue(x.is_special())
305 def test_check_special(self):
306 x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
307 self.assertFalse(x.check_special("FOOBAR"))
308 x = ldb.Dn(self.ldb, "@FOOBAR")
309 self.assertTrue(x.check_special("@FOOBAR"))
312 x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
313 self.assertEquals(2, len(x))
314 x = ldb.Dn(self.ldb, "dc=foo")
315 self.assertEquals(1, len(x))
317 def test_add_child(self):
318 x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
319 self.assertTrue(x.add_child(ldb.Dn(self.ldb, "bla=bloe")))
320 self.assertEquals("bla=bloe,dc=foo,bar=bloe", x.__str__())
322 def test_add_base(self):
323 x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
324 self.assertTrue(x.add_base(ldb.Dn(self.ldb, "bla=bloe")))
325 self.assertEquals("dc=foo,bar=bloe,bla=bloe", x.__str__())
328 x = ldb.Dn(self.ldb, "dc=foo")
329 y = ldb.Dn(self.ldb, "bar=bla")
330 self.assertEquals("dc=foo,bar=bla", str(y + x))
332 def test_parse_ldif(self):
333 msgs = self.ldb.parse_ldif("dn: foo=bar\n")
335 self.assertEquals("foo=bar", str(msg[1].dn))
336 self.assertTrue(isinstance(msg[1], ldb.Message))
338 def test_parse_ldif_more(self):
339 msgs = self.ldb.parse_ldif("dn: foo=bar\n\n\ndn: bar=bar")
341 self.assertEquals("foo=bar", str(msg[1].dn))
343 self.assertEquals("bar=bar", str(msg[1].dn))
345 def test_canonical_string(self):
346 x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
347 self.assertEquals("/bloe/foo", x.canonical_str())
349 def test_canonical_ex_string(self):
350 x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
351 self.assertEquals("/bloe\nfoo", x.canonical_ex_str())
354 class LdbMsgTests(unittest.TestCase):
356 self.msg = ldb.Message()
358 def test_init_dn(self):
359 self.msg = ldb.Message(ldb.Dn(ldb.Ldb(), "dc=foo"))
360 self.assertEquals("dc=foo", str(self.msg.dn))
362 def test_iter_items(self):
363 self.assertEquals(0, len(self.msg.items()))
364 self.msg.dn = ldb.Dn(ldb.Ldb("foo.tdb"), "dc=foo")
365 self.assertEquals(1, len(self.msg.items()))
368 self.msg.dn = ldb.Dn(ldb.Ldb("foo.tdb"), "dc=foo")
369 self.msg["dc"] = "foo"
370 self.assertEquals("Message({'dn': Dn('dc=foo'), 'dc': MessageElement(['foo'])})", repr(self.msg))
373 self.assertEquals(0, len(self.msg))
375 def test_notpresent(self):
376 self.assertRaises(KeyError, lambda: self.msg["foo"])
381 def test_add_value(self):
382 self.assertEquals(0, len(self.msg))
383 self.msg["foo"] = ["foo"]
384 self.assertEquals(1, len(self.msg))
386 def test_add_value_multiple(self):
387 self.assertEquals(0, len(self.msg))
388 self.msg["foo"] = ["foo", "bla"]
389 self.assertEquals(1, len(self.msg))
390 self.assertEquals(["foo", "bla"], list(self.msg["foo"]))
392 def test_set_value(self):
393 self.msg["foo"] = ["fool"]
394 self.assertEquals(["fool"], list(self.msg["foo"]))
395 self.msg["foo"] = ["bar"]
396 self.assertEquals(["bar"], list(self.msg["foo"]))
399 self.msg.dn = ldb.Dn(ldb.Ldb("foo.tdb"), "@BASEINFO")
400 self.msg["foo"] = ["bla"]
401 self.msg["bar"] = ["bla"]
402 self.assertEquals(["dn", "foo", "bar"], self.msg.keys())
405 self.msg.dn = ldb.Dn(ldb.Ldb("foo.ldb"), "@BASEINFO")
406 self.assertEquals("@BASEINFO", self.msg.dn.__str__())
408 def test_get_dn(self):
409 self.msg.dn = ldb.Dn(ldb.Ldb("foo.tdb"), "@BASEINFO")
410 self.assertEquals("@BASEINFO", self.msg.get("dn").__str__())
412 def test_get_other(self):
413 self.msg["foo"] = ["bar"]
414 self.assertEquals("bar", self.msg.get("foo")[0])
416 def test_get_unknown(self):
417 self.assertRaises(KeyError, self.msg.get, "lalalala")
420 class MessageElementTests(unittest.TestCase):
421 def test_cmp_element(self):
422 x = ldb.MessageElement(["foo"])
423 y = ldb.MessageElement(["foo"])
424 z = ldb.MessageElement(["bzr"])
425 self.assertEquals(x, y)
426 self.assertNotEquals(x, z)
428 def test_create_iterable(self):
429 x = ldb.MessageElement(["foo"])
430 self.assertEquals(["foo"], list(x))
433 x = ldb.MessageElement(["foo"])
434 self.assertEquals("MessageElement(['foo'])", repr(x))
435 x = ldb.MessageElement(["foo", "bla"])
436 self.assertEquals("MessageElement(['foo','bla'])", repr(x))
438 def test_get_item(self):
439 x = ldb.MessageElement(["foo", "bar"])
440 self.assertEquals("foo", x[0])
441 self.assertEquals("bar", x[1])
442 self.assertRaises(KeyError, lambda: x[-1])
445 x = ldb.MessageElement(["foo", "bar"])
446 self.assertEquals(2, len(x))
449 x = ldb.MessageElement(["foo", "bar"])
450 self.assertEquals(["foo", "bar"], x)
451 x = ldb.MessageElement(["foo"])
452 self.assertEquals("foo", x)
457 class ModuleTests(unittest.TestCase):
458 def test_register_module(self):
459 ldb.register_module(ExampleModule())
461 if __name__ == '__main__':
463 unittest.TestProgram()