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("build/lib.linux-i686-2.4")
16 class NoContextTests(unittest
.TestCase
):
18 def test_valid_attr_name(self
):
19 self
.assertTrue(ldb
.valid_attr_name("foo"))
20 self
.assertFalse(ldb
.valid_attr_name("24foo"))
22 def test_timestring(self
):
23 self
.assertEquals("19700101000000.0Z", ldb
.timestring(0))
24 self
.assertEquals("20071119191012.0Z", ldb
.timestring(1195499412))
26 def test_string_to_time(self
):
27 self
.assertEquals(0, ldb
.string_to_time("19700101000000.0Z"))
28 self
.assertEquals(1195499412, ldb
.string_to_time("20071119191012.0Z"))
31 class SimpleLdb(unittest
.TestCase
):
33 def test_connect(self
):
36 def test_connect_none(self
):
39 def test_connect_later(self
):
45 self
.assertTrue(repr(x
).startswith("<ldb connection"))
47 def test_set_create_perms(self
):
49 x
.set_create_perms(0600)
51 def test_set_modules_dir(self
):
53 x
.set_modules_dir("/tmp")
55 def test_modules_none(self
):
57 self
.assertEquals([], x
.modules())
59 def test_modules_tdb(self
):
60 x
= ldb
.Ldb("bar.ldb")
61 self
.assertEquals("[<ldb module 'tdb'>]", repr(x
.modules()))
63 def test_search(self
):
64 l
= ldb
.Ldb(filename())
65 self
.assertEquals(len(l
.search()), 1)
67 def test_search_controls(self
):
68 l
= ldb
.Ldb(filename())
69 self
.assertEquals(len(l
.search(controls
=["paged_results:0:5"])), 1)
71 def test_search_attrs(self
):
72 l
= ldb
.Ldb(filename())
73 self
.assertEquals(len(l
.search(ldb
.Dn(l
, ""), ldb
.SCOPE_SUBTREE
, "(dc=*)", ["dc"])), 0)
75 def test_search_string_dn(self
):
76 l
= ldb
.Ldb(filename())
77 self
.assertEquals(len(l
.search("", ldb
.SCOPE_SUBTREE
, "(dc=*)", ["dc"])), 0)
79 def test_search_attr_string(self
):
80 l
= ldb
.Ldb("foo.tdb")
81 self
.assertRaises(TypeError, l
.search
, attrs
="dc")
83 def test_opaque(self
):
84 l
= ldb
.Ldb(filename())
85 l
.set_opaque("my_opaque", l
)
86 self
.assertTrue(l
.get_opaque("my_opaque") is not None)
87 self
.assertEquals(None, l
.get_opaque("unknown"))
89 def test_search_scope_base(self
):
90 l
= ldb
.Ldb(filename())
91 self
.assertEquals(len(l
.search(ldb
.Dn(l
, "dc=foo1"),
92 ldb
.SCOPE_ONELEVEL
)), 0)
94 def test_delete(self
):
95 l
= ldb
.Ldb(filename())
96 self
.assertRaises(ldb
.LdbError
, lambda: l
.delete(ldb
.Dn(l
, "dc=foo2")))
98 def test_contains(self
):
99 l
= ldb
.Ldb(filename())
100 self
.assertFalse(ldb
.Dn(l
, "dc=foo3") in l
)
101 l
= ldb
.Ldb(filename())
103 m
.dn
= ldb
.Dn(l
, "dc=foo3")
107 self
.assertTrue(ldb
.Dn(l
, "dc=foo3") in l
)
111 def test_get_config_basedn(self
):
112 l
= ldb
.Ldb(filename())
113 self
.assertEquals(None, l
.get_config_basedn())
115 def test_get_root_basedn(self
):
116 l
= ldb
.Ldb(filename())
117 self
.assertEquals(None, l
.get_root_basedn())
119 def test_get_schema_basedn(self
):
120 l
= ldb
.Ldb(filename())
121 self
.assertEquals(None, l
.get_schema_basedn())
123 def test_get_default_basedn(self
):
124 l
= ldb
.Ldb(filename())
125 self
.assertEquals(None, l
.get_default_basedn())
128 l
= ldb
.Ldb(filename())
130 m
.dn
= ldb
.Dn(l
, "dc=foo4")
132 self
.assertEquals(len(l
.search()), 1)
135 self
.assertEquals(len(l
.search()), 2)
137 l
.delete(ldb
.Dn(l
, "dc=foo4"))
139 def test_add_w_unhandled_ctrl(self
):
140 l
= ldb
.Ldb(filename())
142 m
.dn
= ldb
.Dn(l
, "dc=foo4")
144 self
.assertEquals(len(l
.search()), 1)
145 self
.assertRaises(ldb
.LdbError
, lambda: l
.add(m
,["search_options:1:2"]))
147 def test_add_dict(self
):
148 l
= ldb
.Ldb(filename())
149 m
= {"dn": ldb
.Dn(l
, "dc=foo5"),
151 self
.assertEquals(len(l
.search()), 1)
154 self
.assertEquals(len(l
.search()), 2)
156 l
.delete(ldb
.Dn(l
, "dc=foo5"))
158 def test_add_dict_string_dn(self
):
159 l
= ldb
.Ldb(filename())
160 m
= {"dn": "dc=foo6", "bla": "bla"}
161 self
.assertEquals(len(l
.search()), 1)
164 self
.assertEquals(len(l
.search()), 2)
166 l
.delete(ldb
.Dn(l
, "dc=foo6"))
168 def test_rename(self
):
169 l
= ldb
.Ldb(filename())
171 m
.dn
= ldb
.Dn(l
, "dc=foo7")
173 self
.assertEquals(len(l
.search()), 1)
176 l
.rename(ldb
.Dn(l
, "dc=foo7"), ldb
.Dn(l
, "dc=bar"))
177 self
.assertEquals(len(l
.search()), 2)
179 l
.delete(ldb
.Dn(l
, "dc=bar"))
181 def test_rename_string_dns(self
):
182 l
= ldb
.Ldb(filename())
184 m
.dn
= ldb
.Dn(l
, "dc=foo8")
186 self
.assertEquals(len(l
.search()), 1)
188 self
.assertEquals(len(l
.search()), 2)
190 l
.rename("dc=foo8", "dc=bar")
191 self
.assertEquals(len(l
.search()), 2)
193 l
.delete(ldb
.Dn(l
, "dc=bar"))
195 def test_modify_delete(self
):
196 l
= ldb
.Ldb(filename())
198 m
.dn
= ldb
.Dn(l
, "dc=modifydelete")
201 rm
= l
.search(m
.dn
)[0]
202 self
.assertEquals(["1234"], list(rm
["bla"]))
205 m
.dn
= ldb
.Dn(l
, "dc=modifydelete")
206 m
["bla"] = ldb
.MessageElement([], ldb
.FLAG_MOD_DELETE
, "bla")
207 self
.assertEquals(ldb
.FLAG_MOD_DELETE
, m
["bla"].flags())
209 rm
= l
.search(m
.dn
)[0]
210 self
.assertEquals(1, len(rm
))
211 rm
= l
.search(m
.dn
, attrs
=["bla"])[0]
212 self
.assertEquals(0, len(rm
))
214 l
.delete(ldb
.Dn(l
, "dc=modifydelete"))
216 def test_modify_add(self
):
217 l
= ldb
.Ldb(filename())
219 m
.dn
= ldb
.Dn(l
, "dc=add")
224 m
.dn
= ldb
.Dn(l
, "dc=add")
225 m
["bla"] = ldb
.MessageElement(["456"], ldb
.FLAG_MOD_ADD
, "bla")
226 self
.assertEquals(ldb
.FLAG_MOD_ADD
, m
["bla"].flags())
228 rm
= l
.search(m
.dn
)[0]
229 self
.assertEquals(2, len(rm
))
230 self
.assertEquals(["1234", "456"], list(rm
["bla"]))
232 l
.delete(ldb
.Dn(l
, "dc=add"))
234 def test_modify_replace(self
):
235 l
= ldb
.Ldb(filename())
237 m
.dn
= ldb
.Dn(l
, "dc=modify2")
238 m
["bla"] = ["1234", "456"]
242 m
.dn
= ldb
.Dn(l
, "dc=modify2")
243 m
["bla"] = ldb
.MessageElement(["789"], ldb
.FLAG_MOD_REPLACE
, "bla")
244 self
.assertEquals(ldb
.FLAG_MOD_REPLACE
, m
["bla"].flags())
246 rm
= l
.search(m
.dn
)[0]
247 self
.assertEquals(2, len(rm
))
248 self
.assertEquals(["789"], list(rm
["bla"]))
249 rm
= l
.search(m
.dn
, attrs
=["bla"])[0]
250 self
.assertEquals(1, len(rm
))
252 l
.delete(ldb
.Dn(l
, "dc=modify2"))
254 def test_modify_flags_change(self
):
255 l
= ldb
.Ldb(filename())
257 m
.dn
= ldb
.Dn(l
, "dc=add")
262 m
.dn
= ldb
.Dn(l
, "dc=add")
263 m
["bla"] = ldb
.MessageElement(["456"], ldb
.FLAG_MOD_ADD
, "bla")
264 self
.assertEquals(ldb
.FLAG_MOD_ADD
, m
["bla"].flags())
266 rm
= l
.search(m
.dn
)[0]
267 self
.assertEquals(2, len(rm
))
268 self
.assertEquals(["1234", "456"], list(rm
["bla"]))
270 #Now create another modify, but switch the flags before we do it
271 m
["bla"] = ldb
.MessageElement(["456"], ldb
.FLAG_MOD_ADD
, "bla")
272 m
["bla"].set_flags(ldb
.FLAG_MOD_DELETE
)
274 rm
= l
.search(m
.dn
, attrs
=["bla"])[0]
275 self
.assertEquals(1, len(rm
))
276 self
.assertEquals(["1234"], list(rm
["bla"]))
279 l
.delete(ldb
.Dn(l
, "dc=add"))
281 def test_transaction_commit(self
):
282 l
= ldb
.Ldb(filename())
283 l
.transaction_start()
284 m
= ldb
.Message(ldb
.Dn(l
, "dc=foo9"))
287 l
.transaction_commit()
290 def test_transaction_cancel(self
):
291 l
= ldb
.Ldb(filename())
292 l
.transaction_start()
293 m
= ldb
.Message(ldb
.Dn(l
, "dc=foo10"))
296 l
.transaction_cancel()
297 self
.assertEquals(0, len(l
.search(ldb
.Dn(l
, "dc=foo10"))))
299 def test_set_debug(self
):
300 def my_report_fn(level
, text
):
302 l
= ldb
.Ldb(filename())
303 l
.set_debug(my_report_fn
)
305 def test_zero_byte_string(self
):
306 """Testing we do not get trapped in the \0 byte in a property string."""
307 l
= ldb
.Ldb(filename())
310 "objectclass" : "user",
311 "cN" : "LDAPtestUSER",
312 "givenname" : "ldap",
313 "displayname" : "foo\0bar",
315 res
= l
.search(expression
="(dn=dc=somedn)")
316 self
.assertEquals("foo\0bar", res
[0]["displayname"][0])
319 class DnTests(unittest
.TestCase
):
322 self
.ldb
= ldb
.Ldb(filename())
324 def test_set_dn_invalid(self
):
328 self
.assertRaises(TypeError, assign
)
331 x
= ldb
.Dn(self
.ldb
, "dc=foo11,bar=bloe")
332 y
= ldb
.Dn(self
.ldb
, "dc=foo11,bar=bloe")
333 self
.assertEquals(x
, y
)
336 x
= ldb
.Dn(self
.ldb
, "dc=foo12,bar=bloe")
337 self
.assertEquals(x
.__str
__(), "dc=foo12,bar=bloe")
340 x
= ldb
.Dn(self
.ldb
, "dc=foo13,bla=blie")
341 self
.assertEquals(x
.__repr
__(), "Dn('dc=foo13,bla=blie')")
343 def test_get_casefold(self
):
344 x
= ldb
.Dn(self
.ldb
, "dc=foo14,bar=bloe")
345 self
.assertEquals(x
.get_casefold(), "DC=FOO14,BAR=bloe")
347 def test_validate(self
):
348 x
= ldb
.Dn(self
.ldb
, "dc=foo15,bar=bloe")
349 self
.assertTrue(x
.validate())
351 def test_parent(self
):
352 x
= ldb
.Dn(self
.ldb
, "dc=foo16,bar=bloe")
353 self
.assertEquals("bar=bloe", x
.parent().__str
__())
355 def test_parent_nonexistant(self
):
356 x
= ldb
.Dn(self
.ldb
, "@BLA")
357 self
.assertEquals(None, x
.parent())
359 def test_compare(self
):
360 x
= ldb
.Dn(self
.ldb
, "dc=foo17,bar=bloe")
361 y
= ldb
.Dn(self
.ldb
, "dc=foo17,bar=bloe")
362 self
.assertEquals(x
, y
)
363 z
= ldb
.Dn(self
.ldb
, "dc=foo17,bar=blie")
364 self
.assertNotEquals(z
, y
)
366 def test_is_valid(self
):
367 x
= ldb
.Dn(self
.ldb
, "dc=foo18,dc=bloe")
368 self
.assertTrue(x
.is_valid())
369 x
= ldb
.Dn(self
.ldb
, "")
370 # is_valid()'s return values appears to be a side effect of
371 # some other ldb functions. yuck.
372 # self.assertFalse(x.is_valid())
374 def test_is_special(self
):
375 x
= ldb
.Dn(self
.ldb
, "dc=foo19,bar=bloe")
376 self
.assertFalse(x
.is_special())
377 x
= ldb
.Dn(self
.ldb
, "@FOOBAR")
378 self
.assertTrue(x
.is_special())
380 def test_check_special(self
):
381 x
= ldb
.Dn(self
.ldb
, "dc=foo20,bar=bloe")
382 self
.assertFalse(x
.check_special("FOOBAR"))
383 x
= ldb
.Dn(self
.ldb
, "@FOOBAR")
384 self
.assertTrue(x
.check_special("@FOOBAR"))
387 x
= ldb
.Dn(self
.ldb
, "dc=foo21,bar=bloe")
388 self
.assertEquals(2, len(x
))
389 x
= ldb
.Dn(self
.ldb
, "dc=foo21")
390 self
.assertEquals(1, len(x
))
392 def test_add_child(self
):
393 x
= ldb
.Dn(self
.ldb
, "dc=foo22,bar=bloe")
394 self
.assertTrue(x
.add_child(ldb
.Dn(self
.ldb
, "bla=bloe")))
395 self
.assertEquals("bla=bloe,dc=foo22,bar=bloe", x
.__str
__())
397 def test_add_base(self
):
398 x
= ldb
.Dn(self
.ldb
, "dc=foo23,bar=bloe")
399 base
= ldb
.Dn(self
.ldb
, "bla=bloe")
400 self
.assertTrue(x
.add_base(base
))
401 self
.assertEquals("dc=foo23,bar=bloe,bla=bloe", x
.__str
__())
404 x
= ldb
.Dn(self
.ldb
, "dc=foo24")
405 y
= ldb
.Dn(self
.ldb
, "bar=bla")
406 self
.assertEquals("dc=foo24,bar=bla", str(y
+ x
))
408 def test_parse_ldif(self
):
409 msgs
= self
.ldb
.parse_ldif("dn: foo=bar\n")
411 self
.assertEquals("foo=bar", str(msg
[1].dn
))
412 self
.assertTrue(isinstance(msg
[1], ldb
.Message
))
413 ldif
= self
.ldb
.write_ldif(msg
[1], ldb
.CHANGETYPE_NONE
)
414 self
.assertEquals("dn: foo=bar\n\n", ldif
)
416 def test_parse_ldif_more(self
):
417 msgs
= self
.ldb
.parse_ldif("dn: foo=bar\n\n\ndn: bar=bar")
419 self
.assertEquals("foo=bar", str(msg
[1].dn
))
421 self
.assertEquals("bar=bar", str(msg
[1].dn
))
423 def test_canonical_string(self
):
424 x
= ldb
.Dn(self
.ldb
, "dc=foo25,bar=bloe")
425 self
.assertEquals("/bloe/foo25", x
.canonical_str())
427 def test_canonical_ex_string(self
):
428 x
= ldb
.Dn(self
.ldb
, "dc=foo26,bar=bloe")
429 self
.assertEquals("/bloe\nfoo26", x
.canonical_ex_str())
432 class LdbMsgTests(unittest
.TestCase
):
435 self
.msg
= ldb
.Message()
437 def test_init_dn(self
):
438 self
.msg
= ldb
.Message(ldb
.Dn(ldb
.Ldb(), "dc=foo27"))
439 self
.assertEquals("dc=foo27", str(self
.msg
.dn
))
441 def test_iter_items(self
):
442 self
.assertEquals(0, len(self
.msg
.items()))
443 self
.msg
.dn
= ldb
.Dn(ldb
.Ldb("foo.tdb"), "dc=foo28")
444 self
.assertEquals(1, len(self
.msg
.items()))
447 self
.msg
.dn
= ldb
.Dn(ldb
.Ldb("foo.tdb"), "dc=foo29")
448 self
.msg
["dc"] = "foo"
449 self
.assertEquals("Message({'dn': Dn('dc=foo29'), 'dc': MessageElement(['foo'])})", repr(self
.msg
))
452 self
.assertEquals(0, len(self
.msg
))
454 def test_notpresent(self
):
455 self
.assertRaises(KeyError, lambda: self
.msg
["foo"])
460 def test_add_value(self
):
461 self
.assertEquals(0, len(self
.msg
))
462 self
.msg
["foo"] = ["foo"]
463 self
.assertEquals(1, len(self
.msg
))
465 def test_add_value_multiple(self
):
466 self
.assertEquals(0, len(self
.msg
))
467 self
.msg
["foo"] = ["foo", "bla"]
468 self
.assertEquals(1, len(self
.msg
))
469 self
.assertEquals(["foo", "bla"], list(self
.msg
["foo"]))
471 def test_set_value(self
):
472 self
.msg
["foo"] = ["fool"]
473 self
.assertEquals(["fool"], list(self
.msg
["foo"]))
474 self
.msg
["foo"] = ["bar"]
475 self
.assertEquals(["bar"], list(self
.msg
["foo"]))
478 self
.msg
.dn
= ldb
.Dn(ldb
.Ldb("foo.tdb"), "@BASEINFO")
479 self
.msg
["foo"] = ["bla"]
480 self
.msg
["bar"] = ["bla"]
481 self
.assertEquals(["dn", "foo", "bar"], self
.msg
.keys())
484 self
.msg
.dn
= ldb
.Dn(ldb
.Ldb(filename()), "@BASEINFO")
485 self
.assertEquals("@BASEINFO", self
.msg
.dn
.__str
__())
487 def test_get_dn(self
):
488 self
.msg
.dn
= ldb
.Dn(ldb
.Ldb("foo.tdb"), "@BASEINFO")
489 self
.assertEquals("@BASEINFO", self
.msg
.get("dn").__str
__())
491 def test_get_invalid(self
):
492 self
.msg
.dn
= ldb
.Dn(ldb
.Ldb("foo.tdb"), "@BASEINFO")
493 self
.assertRaises(TypeError, self
.msg
.get
, 42)
495 def test_get_other(self
):
496 self
.msg
["foo"] = ["bar"]
497 self
.assertEquals("bar", self
.msg
.get("foo")[0])
499 def test_get_unknown(self
):
500 self
.assertEquals(None, self
.msg
.get("lalalala"))
502 def test_msg_diff(self
):
504 msgs
= l
.parse_ldif("dn: foo=bar\nfoo: bar\nbaz: do\n\ndn: foo=bar\nfoo: bar\nbaz: dont\n")
505 msg1
= msgs
.next()[1]
506 msg2
= msgs
.next()[1]
507 msgdiff
= l
.msg_diff(msg1
, msg2
)
508 self
.assertEquals("foo=bar", msgdiff
.get("dn").__str
__())
509 self
.assertRaises(KeyError, lambda: msgdiff
["foo"])
510 self
.assertEquals(1, len(msgdiff
))
514 class MessageElementTests(unittest
.TestCase
):
516 def test_cmp_element(self
):
517 x
= ldb
.MessageElement(["foo"])
518 y
= ldb
.MessageElement(["foo"])
519 z
= ldb
.MessageElement(["bzr"])
520 self
.assertEquals(x
, y
)
521 self
.assertNotEquals(x
, z
)
523 def test_create_iterable(self
):
524 x
= ldb
.MessageElement(["foo"])
525 self
.assertEquals(["foo"], list(x
))
528 x
= ldb
.MessageElement(["foo"])
529 self
.assertEquals("MessageElement(['foo'])", repr(x
))
530 x
= ldb
.MessageElement(["foo", "bla"])
531 self
.assertEquals(2, len(x
))
532 self
.assertEquals("MessageElement(['foo','bla'])", repr(x
))
534 def test_get_item(self
):
535 x
= ldb
.MessageElement(["foo", "bar"])
536 self
.assertEquals("foo", x
[0])
537 self
.assertEquals("bar", x
[1])
538 self
.assertEquals("bar", x
[-1])
539 self
.assertRaises(IndexError, lambda: x
[45])
542 x
= ldb
.MessageElement(["foo", "bar"])
543 self
.assertEquals(2, len(x
))
546 x
= ldb
.MessageElement(["foo", "bar"])
547 y
= ldb
.MessageElement(["foo", "bar"])
548 self
.assertEquals(y
, x
)
549 x
= ldb
.MessageElement(["foo"])
550 self
.assertNotEquals(y
, x
)
551 y
= ldb
.MessageElement(["foo"])
552 self
.assertEquals(y
, x
)
555 class ModuleTests(unittest
.TestCase
):
557 def test_register_module(self
):
560 ldb
.register_module(ExampleModule
)
562 def test_use_module(self
):
567 def __init__(self
, ldb
, next
):
571 def search(self
, *args
, **kwargs
):
572 return self
.next
.search(*args
, **kwargs
)
574 ldb
.register_module(ExampleModule
)
575 if os
.path
.exists("usemodule.ldb"):
576 os
.unlink("usemodule.ldb")
577 l
= ldb
.Ldb("usemodule.ldb")
578 l
.add({"dn": "@MODULES", "@LIST": "bla"})
579 self
.assertEquals([], ops
)
580 l
= ldb
.Ldb("usemodule.ldb")
581 self
.assertEquals(["init"], ops
)
584 if __name__
== '__main__':
586 unittest
.TestProgram()