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_modules_none(self
):
53 self
.assertEquals([], x
.modules())
55 def test_modules_tdb(self
):
56 x
= ldb
.Ldb("bar.ldb")
57 self
.assertEquals("[<ldb module 'tdb'>]", repr(x
.modules()))
59 def test_search(self
):
60 l
= ldb
.Ldb("foo.ldb")
61 self
.assertEquals(len(l
.search()), 1)
63 def test_search_controls(self
):
64 l
= ldb
.Ldb("foo.ldb")
65 self
.assertEquals(len(l
.search(controls
=["paged_results:0:5"])), 1)
67 def test_search_attrs(self
):
68 l
= ldb
.Ldb("foo.ldb")
69 self
.assertEquals(len(l
.search(ldb
.Dn(l
, ""), ldb
.SCOPE_SUBTREE
, "(dc=*)", ["dc"])), 0)
71 def test_search_string_dn(self
):
72 l
= ldb
.Ldb("foo.ldb")
73 self
.assertEquals(len(l
.search("", ldb
.SCOPE_SUBTREE
, "(dc=*)", ["dc"])), 0)
75 def test_search_attr_string(self
):
76 l
= ldb
.Ldb("foo.tdb")
77 self
.assertRaises(TypeError, l
.search
, attrs
="dc")
79 def test_opaque(self
):
80 l
= ldb
.Ldb("foo.ldb")
81 l
.set_opaque("my_opaque", l
)
82 self
.assertTrue(l
.get_opaque("my_opaque") is not None)
83 self
.assertEquals(None, l
.get_opaque("unknown"))
85 def test_parse_control_strings(self
):
86 l
= ldb
.Ldb("foo.ldb")
87 self
.assertRaises(ldb
.LdbError
, l
.parse_control_strings
, ["foo", "bar"])
88 self
.assertTrue(l
.parse_control_strings(["paged_results:0:5"]) is not None)
90 def test_search_scope_base(self
):
91 l
= ldb
.Ldb("foo.ldb")
92 self
.assertEquals(len(l
.search(ldb
.Dn(l
, "dc=foo"),
93 ldb
.SCOPE_ONELEVEL
)), 0)
95 def test_delete(self
):
96 l
= ldb
.Ldb("foo.ldb")
97 self
.assertRaises(ldb
.LdbError
, lambda: l
.delete(ldb
.Dn(l
, "dc=foo")))
99 def test_contains(self
):
100 l
= ldb
.Ldb("foo.ldb")
101 self
.assertFalse(ldb
.Dn(l
, "dc=foo") in l
)
102 l
= ldb
.Ldb("foo.ldb")
104 m
.dn
= ldb
.Dn(l
, "dc=foo")
108 self
.assertTrue(ldb
.Dn(l
, "dc=foo") in l
)
112 def test_get_config_basedn(self
):
113 l
= ldb
.Ldb("foo.ldb")
114 self
.assertEquals(None, l
.get_config_basedn())
116 def test_get_root_basedn(self
):
117 l
= ldb
.Ldb("foo.ldb")
118 self
.assertEquals(None, l
.get_root_basedn())
120 def test_get_schema_basedn(self
):
121 l
= ldb
.Ldb("foo.ldb")
122 self
.assertEquals(None, l
.get_schema_basedn())
124 def test_get_default_basedn(self
):
125 l
= ldb
.Ldb("foo.ldb")
126 self
.assertEquals(None, l
.get_default_basedn())
129 l
= ldb
.Ldb("foo.ldb")
131 m
.dn
= ldb
.Dn(l
, "dc=foo")
133 self
.assertEquals(len(l
.search()), 1)
136 self
.assertEquals(len(l
.search()), 2)
138 l
.delete(ldb
.Dn(l
, "dc=foo"))
140 def test_add_dict(self
):
141 l
= ldb
.Ldb("foo.ldb")
142 m
= {"dn": ldb
.Dn(l
, "dc=foo"),
144 self
.assertEquals(len(l
.search()), 1)
147 self
.assertEquals(len(l
.search()), 2)
149 l
.delete(ldb
.Dn(l
, "dc=foo"))
151 def test_add_dict_string_dn(self
):
152 l
= ldb
.Ldb("foo.ldb")
153 m
= {"dn": "dc=foo", "bla": "bla"}
154 self
.assertEquals(len(l
.search()), 1)
157 self
.assertEquals(len(l
.search()), 2)
159 l
.delete(ldb
.Dn(l
, "dc=foo"))
161 def test_rename(self
):
162 l
= ldb
.Ldb("foo.ldb")
164 m
.dn
= ldb
.Dn(l
, "dc=foo")
166 self
.assertEquals(len(l
.search()), 1)
169 l
.rename(ldb
.Dn(l
, "dc=foo"), ldb
.Dn(l
, "dc=bar"))
170 self
.assertEquals(len(l
.search()), 2)
172 l
.delete(ldb
.Dn(l
, "dc=bar"))
174 def test_rename_string_dns(self
):
175 l
= ldb
.Ldb("foo.ldb")
177 m
.dn
= ldb
.Dn(l
, "dc=foo")
179 self
.assertEquals(len(l
.search()), 1)
182 l
.rename("dc=foo", "dc=bar")
183 self
.assertEquals(len(l
.search()), 2)
185 l
.delete(ldb
.Dn(l
, "dc=bar"))
187 def test_modify_delete(self
):
188 l
= ldb
.Ldb("foo.ldb")
190 m
.dn
= ldb
.Dn(l
, "dc=modifydelete")
193 rm
= l
.search(m
.dn
)[0]
194 self
.assertEquals(["1234"], list(rm
["bla"]))
197 m
.dn
= ldb
.Dn(l
, "dc=modifydelete")
198 m
["bla"] = ldb
.MessageElement([], ldb
.CHANGETYPE_DELETE
, "bla")
200 rm
= l
.search(m
.dn
)[0]
201 self
.assertEquals(1, len(rm
))
203 l
.delete(ldb
.Dn(l
, "dc=modifydelete"))
205 def test_modify_add(self
):
206 l
= ldb
.Ldb("foo.ldb")
208 m
.dn
= ldb
.Dn(l
, "dc=add")
213 m
.dn
= ldb
.Dn(l
, "dc=add")
214 m
["bla"] = ldb
.MessageElement(["456"], ldb
.CHANGETYPE_ADD
, "bla")
216 rm
= l
.search(m
.dn
)[0]
217 self
.assertEquals(2, len(rm
))
218 self
.assertEquals(["1234", "456"], list(rm
["bla"]))
220 l
.delete(ldb
.Dn(l
, "dc=add"))
222 def test_modify_modify(self
):
223 l
= ldb
.Ldb("foo.ldb")
225 m
.dn
= ldb
.Dn(l
, "dc=modify2")
226 m
["bla"] = ["1234", "456"]
230 m
.dn
= ldb
.Dn(l
, "dc=modify2")
231 m
["bla"] = ldb
.MessageElement(["456"], ldb
.CHANGETYPE_MODIFY
, "bla")
233 rm
= l
.search(m
.dn
)[0]
234 self
.assertEquals(2, len(rm
))
235 self
.assertEquals(["1234"], list(rm
["bla"]))
237 l
.delete(ldb
.Dn(l
, "dc=modify2"))
239 def test_transaction_commit(self
):
240 l
= ldb
.Ldb("foo.ldb")
241 l
.transaction_start()
242 m
= ldb
.Message(ldb
.Dn(l
, "dc=foo"))
245 l
.transaction_commit()
248 def test_transaction_cancel(self
):
249 l
= ldb
.Ldb("foo.ldb")
250 l
.transaction_start()
251 m
= ldb
.Message(ldb
.Dn(l
, "dc=foo"))
254 l
.transaction_cancel()
255 self
.assertEquals(0, len(l
.search(ldb
.Dn(l
, "dc=foo"))))
257 def test_set_debug(self
):
258 def my_report_fn(level
, text
):
260 l
= ldb
.Ldb("foo.ldb")
261 l
.set_debug(my_report_fn
)
264 class DnTests(unittest
.TestCase
):
266 self
.ldb
= ldb
.Ldb("foo.ldb")
268 def test_eq_str(self
):
269 x
= ldb
.Dn(self
.ldb
, "dc=foo,bar=bloe")
270 self
.assertEquals("dc=foo,bar=bloe", x
)
273 x
= ldb
.Dn(self
.ldb
, "dc=foo,bar=bloe")
274 self
.assertEquals(x
.__str
__(), "dc=foo,bar=bloe")
277 x
= ldb
.Dn(self
.ldb
, "dc=foo,bla=blie")
278 self
.assertEquals(x
.__repr
__(), "Dn('dc=foo,bla=blie')")
280 def test_get_casefold(self
):
281 x
= ldb
.Dn(self
.ldb
, "dc=foo,bar=bloe")
282 self
.assertEquals(x
.get_casefold(), "DC=FOO,BAR=bloe")
284 def test_validate(self
):
285 x
= ldb
.Dn(self
.ldb
, "dc=foo,bar=bloe")
286 self
.assertTrue(x
.validate())
288 def test_parent(self
):
289 x
= ldb
.Dn(self
.ldb
, "dc=foo,bar=bloe")
290 self
.assertEquals("bar=bloe", x
.parent().__str
__())
292 def test_compare(self
):
293 x
= ldb
.Dn(self
.ldb
, "dc=foo,bar=bloe")
294 y
= ldb
.Dn(self
.ldb
, "dc=foo,bar=bloe")
295 self
.assertEquals(x
, y
)
296 z
= ldb
.Dn(self
.ldb
, "dc=foo,bar=blie")
297 self
.assertNotEquals(z
, y
)
299 def test_is_valid(self
):
300 x
= ldb
.Dn(self
.ldb
, "dc=foo,dc=bloe")
301 self
.assertTrue(x
.is_valid())
302 x
= ldb
.Dn(self
.ldb
, "")
303 # is_valid()'s return values appears to be a side effect of
304 # some other ldb functions. yuck.
305 # self.assertFalse(x.is_valid())
307 def test_is_special(self
):
308 x
= ldb
.Dn(self
.ldb
, "dc=foo,bar=bloe")
309 self
.assertFalse(x
.is_special())
310 x
= ldb
.Dn(self
.ldb
, "@FOOBAR")
311 self
.assertTrue(x
.is_special())
313 def test_check_special(self
):
314 x
= ldb
.Dn(self
.ldb
, "dc=foo,bar=bloe")
315 self
.assertFalse(x
.check_special("FOOBAR"))
316 x
= ldb
.Dn(self
.ldb
, "@FOOBAR")
317 self
.assertTrue(x
.check_special("@FOOBAR"))
320 x
= ldb
.Dn(self
.ldb
, "dc=foo,bar=bloe")
321 self
.assertEquals(2, len(x
))
322 x
= ldb
.Dn(self
.ldb
, "dc=foo")
323 self
.assertEquals(1, len(x
))
325 def test_add_child(self
):
326 x
= ldb
.Dn(self
.ldb
, "dc=foo,bar=bloe")
327 self
.assertTrue(x
.add_child(ldb
.Dn(self
.ldb
, "bla=bloe")))
328 self
.assertEquals("bla=bloe,dc=foo,bar=bloe", x
.__str
__())
330 def test_add_base(self
):
331 x
= ldb
.Dn(self
.ldb
, "dc=foo,bar=bloe")
332 self
.assertTrue(x
.add_base(ldb
.Dn(self
.ldb
, "bla=bloe")))
333 self
.assertEquals("dc=foo,bar=bloe,bla=bloe", x
.__str
__())
336 x
= ldb
.Dn(self
.ldb
, "dc=foo")
337 y
= ldb
.Dn(self
.ldb
, "bar=bla")
338 self
.assertEquals("dc=foo,bar=bla", str(y
+ x
))
340 def test_parse_ldif(self
):
341 msgs
= self
.ldb
.parse_ldif("dn: foo=bar\n")
343 self
.assertEquals("foo=bar", str(msg
[1].dn
))
344 self
.assertTrue(isinstance(msg
[1], ldb
.Message
))
346 def test_parse_ldif_more(self
):
347 msgs
= self
.ldb
.parse_ldif("dn: foo=bar\n\n\ndn: bar=bar")
349 self
.assertEquals("foo=bar", str(msg
[1].dn
))
351 self
.assertEquals("bar=bar", str(msg
[1].dn
))
353 def test_canonical_string(self
):
354 x
= ldb
.Dn(self
.ldb
, "dc=foo,bar=bloe")
355 self
.assertEquals("/bloe/foo", x
.canonical_str())
357 def test_canonical_ex_string(self
):
358 x
= ldb
.Dn(self
.ldb
, "dc=foo,bar=bloe")
359 self
.assertEquals("/bloe\nfoo", x
.canonical_ex_str())
362 class LdbMsgTests(unittest
.TestCase
):
364 self
.msg
= ldb
.Message()
366 def test_init_dn(self
):
367 self
.msg
= ldb
.Message(ldb
.Dn(ldb
.Ldb(), "dc=foo"))
368 self
.assertEquals("dc=foo", str(self
.msg
.dn
))
370 def test_iter_items(self
):
371 self
.assertEquals(0, len(self
.msg
.items()))
372 self
.msg
.dn
= ldb
.Dn(ldb
.Ldb("foo.tdb"), "dc=foo")
373 self
.assertEquals(1, len(self
.msg
.items()))
376 self
.msg
.dn
= ldb
.Dn(ldb
.Ldb("foo.tdb"), "dc=foo")
377 self
.msg
["dc"] = "foo"
378 self
.assertEquals("Message({'dn': Dn('dc=foo'), 'dc': MessageElement(['foo'])})", repr(self
.msg
))
381 self
.assertEquals(0, len(self
.msg
))
383 def test_notpresent(self
):
384 self
.assertRaises(KeyError, lambda: self
.msg
["foo"])
389 def test_add_value(self
):
390 self
.assertEquals(0, len(self
.msg
))
391 self
.msg
["foo"] = ["foo"]
392 self
.assertEquals(1, len(self
.msg
))
394 def test_add_value_multiple(self
):
395 self
.assertEquals(0, len(self
.msg
))
396 self
.msg
["foo"] = ["foo", "bla"]
397 self
.assertEquals(1, len(self
.msg
))
398 self
.assertEquals(["foo", "bla"], list(self
.msg
["foo"]))
400 def test_set_value(self
):
401 self
.msg
["foo"] = ["fool"]
402 self
.assertEquals(["fool"], list(self
.msg
["foo"]))
403 self
.msg
["foo"] = ["bar"]
404 self
.assertEquals(["bar"], list(self
.msg
["foo"]))
407 self
.msg
.dn
= ldb
.Dn(ldb
.Ldb("foo.tdb"), "@BASEINFO")
408 self
.msg
["foo"] = ["bla"]
409 self
.msg
["bar"] = ["bla"]
410 self
.assertEquals(["dn", "foo", "bar"], self
.msg
.keys())
413 self
.msg
.dn
= ldb
.Dn(ldb
.Ldb("foo.ldb"), "@BASEINFO")
414 self
.assertEquals("@BASEINFO", self
.msg
.dn
.__str
__())
416 def test_get_dn(self
):
417 self
.msg
.dn
= ldb
.Dn(ldb
.Ldb("foo.tdb"), "@BASEINFO")
418 self
.assertEquals("@BASEINFO", self
.msg
.get("dn").__str
__())
420 def test_get_other(self
):
421 self
.msg
["foo"] = ["bar"]
422 self
.assertEquals("bar", self
.msg
.get("foo")[0])
424 def test_get_unknown(self
):
425 self
.assertRaises(KeyError, self
.msg
.get
, "lalalala")
428 class MessageElementTests(unittest
.TestCase
):
429 def test_cmp_element(self
):
430 x
= ldb
.MessageElement(["foo"])
431 y
= ldb
.MessageElement(["foo"])
432 z
= ldb
.MessageElement(["bzr"])
433 self
.assertEquals(x
, y
)
434 self
.assertNotEquals(x
, z
)
436 def test_create_iterable(self
):
437 x
= ldb
.MessageElement(["foo"])
438 self
.assertEquals(["foo"], list(x
))
441 x
= ldb
.MessageElement(["foo"])
442 self
.assertEquals("MessageElement(['foo'])", repr(x
))
443 x
= ldb
.MessageElement(["foo", "bla"])
444 self
.assertEquals("MessageElement(['foo','bla'])", repr(x
))
446 def test_get_item(self
):
447 x
= ldb
.MessageElement(["foo", "bar"])
448 self
.assertEquals("foo", x
[0])
449 self
.assertEquals("bar", x
[1])
450 self
.assertRaises(KeyError, lambda: x
[-1])
453 x
= ldb
.MessageElement(["foo", "bar"])
454 self
.assertEquals(2, len(x
))
457 x
= ldb
.MessageElement(["foo", "bar"])
458 self
.assertEquals(["foo", "bar"], x
)
459 x
= ldb
.MessageElement(["foo"])
460 self
.assertEquals("foo", x
)
462 class ModuleTests(unittest
.TestCase
):
463 def test_register_module(self
):
466 ldb
.register_module(ExampleModule
)
468 def test_use_module(self
):
473 def __init__(self
, ldb
, next
):
477 def search(self
, *args
, **kwargs
):
478 return self
.next
.search(*args
, **kwargs
)
480 ldb
.register_module(ExampleModule
)
481 if os
.path
.exists("usemodule.ldb"):
482 os
.unlink("usemodule.ldb")
483 l
= ldb
.Ldb("usemodule.ldb")
484 l
.add({"dn": "@MODULES", "@LIST": "bla"})
485 self
.assertEquals([], ops
)
486 l
= ldb
.Ldb("usemodule.ldb")
487 self
.assertEquals(["init"], ops
)
489 if __name__
== '__main__':
491 unittest
.TestProgram()