2 # Simple tests for the ldb python bindings.
3 # Copyright (C) 2007 Jelmer Vernooij <jelmer@samba.org>
6 from unittest
import TestCase
14 dir_prefix
= os
.path
.join(os
.environ
["SELFTEST_PREFIX"], "tmp")
17 return tempfile
.mktemp(dir=dir_prefix
)
20 class NoContextTests(TestCase
):
22 def test_valid_attr_name(self
):
23 self
.assertTrue(ldb
.valid_attr_name("foo"))
24 self
.assertFalse(ldb
.valid_attr_name("24foo"))
26 def test_timestring(self
):
27 self
.assertEquals("19700101000000.0Z", ldb
.timestring(0))
28 self
.assertEquals("20071119191012.0Z", ldb
.timestring(1195499412))
30 def test_string_to_time(self
):
31 self
.assertEquals(0, ldb
.string_to_time("19700101000000.0Z"))
32 self
.assertEquals(1195499412, ldb
.string_to_time("20071119191012.0Z"))
34 def test_binary_encode(self
):
35 encoded
= ldb
.binary_encode('test\\x')
36 decoded
= ldb
.binary_decode(encoded
)
37 self
.assertEquals(decoded
, 'test\\x')
39 class SimpleLdb(TestCase
):
41 def test_connect(self
):
44 def test_connect_none(self
):
47 def test_connect_later(self
):
53 self
.assertTrue(repr(x
).startswith("<ldb connection"))
55 def test_set_create_perms(self
):
57 x
.set_create_perms(0600)
59 def test_modules_none(self
):
61 self
.assertEquals([], x
.modules())
63 def test_modules_tdb(self
):
64 x
= ldb
.Ldb(filename())
65 self
.assertEquals("[<ldb module 'tdb'>]", repr(x
.modules()))
67 def test_search(self
):
68 l
= ldb
.Ldb(filename())
69 self
.assertEquals(len(l
.search()), 0)
71 def test_search_controls(self
):
72 l
= ldb
.Ldb(filename())
73 self
.assertEquals(len(l
.search(controls
=["paged_results:0:5"])), 0)
75 def test_search_attrs(self
):
76 l
= ldb
.Ldb(filename())
77 self
.assertEquals(len(l
.search(ldb
.Dn(l
, ""), ldb
.SCOPE_SUBTREE
, "(dc=*)", ["dc"])), 0)
79 def test_search_string_dn(self
):
80 l
= ldb
.Ldb(filename())
81 self
.assertEquals(len(l
.search("", ldb
.SCOPE_SUBTREE
, "(dc=*)", ["dc"])), 0)
83 def test_search_attr_string(self
):
84 l
= ldb
.Ldb(filename())
85 self
.assertRaises(TypeError, l
.search
, attrs
="dc")
87 def test_opaque(self
):
88 l
= ldb
.Ldb(filename())
89 l
.set_opaque("my_opaque", l
)
90 self
.assertTrue(l
.get_opaque("my_opaque") is not None)
91 self
.assertEquals(None, l
.get_opaque("unknown"))
93 def test_search_scope_base(self
):
94 l
= ldb
.Ldb(filename())
95 self
.assertEquals(len(l
.search(ldb
.Dn(l
, "dc=foo1"),
96 ldb
.SCOPE_ONELEVEL
)), 0)
98 def test_delete(self
):
99 l
= ldb
.Ldb(filename())
100 self
.assertRaises(ldb
.LdbError
, lambda: l
.delete(ldb
.Dn(l
, "dc=foo2")))
102 def test_delete_w_unhandled_ctrl(self
):
103 l
= ldb
.Ldb(filename())
105 m
.dn
= ldb
.Dn(l
, "dc=foo1")
108 self
.assertRaises(ldb
.LdbError
, lambda: l
.delete(m
.dn
, ["search_options:1:2"]))
111 def test_contains(self
):
114 self
.assertFalse(ldb
.Dn(l
, "dc=foo3") in l
)
117 m
.dn
= ldb
.Dn(l
, "dc=foo3")
121 self
.assertTrue(ldb
.Dn(l
, "dc=foo3") in l
)
125 def test_get_config_basedn(self
):
126 l
= ldb
.Ldb(filename())
127 self
.assertEquals(None, l
.get_config_basedn())
129 def test_get_root_basedn(self
):
130 l
= ldb
.Ldb(filename())
131 self
.assertEquals(None, l
.get_root_basedn())
133 def test_get_schema_basedn(self
):
134 l
= ldb
.Ldb(filename())
135 self
.assertEquals(None, l
.get_schema_basedn())
137 def test_get_default_basedn(self
):
138 l
= ldb
.Ldb(filename())
139 self
.assertEquals(None, l
.get_default_basedn())
142 l
= ldb
.Ldb(filename())
144 m
.dn
= ldb
.Dn(l
, "dc=foo4")
146 self
.assertEquals(len(l
.search()), 0)
149 self
.assertEquals(len(l
.search()), 1)
151 l
.delete(ldb
.Dn(l
, "dc=foo4"))
153 def test_add_w_unhandled_ctrl(self
):
154 l
= ldb
.Ldb(filename())
156 m
.dn
= ldb
.Dn(l
, "dc=foo4")
158 self
.assertEquals(len(l
.search()), 0)
159 self
.assertRaises(ldb
.LdbError
, lambda: l
.add(m
,["search_options:1:2"]))
161 def test_add_dict(self
):
162 l
= ldb
.Ldb(filename())
163 m
= {"dn": ldb
.Dn(l
, "dc=foo5"),
165 self
.assertEquals(len(l
.search()), 0)
168 self
.assertEquals(len(l
.search()), 1)
170 l
.delete(ldb
.Dn(l
, "dc=foo5"))
172 def test_add_dict_string_dn(self
):
173 l
= ldb
.Ldb(filename())
174 m
= {"dn": "dc=foo6", "bla": "bla"}
175 self
.assertEquals(len(l
.search()), 0)
178 self
.assertEquals(len(l
.search()), 1)
180 l
.delete(ldb
.Dn(l
, "dc=foo6"))
182 def test_rename(self
):
183 l
= ldb
.Ldb(filename())
185 m
.dn
= ldb
.Dn(l
, "dc=foo7")
187 self
.assertEquals(len(l
.search()), 0)
190 l
.rename(ldb
.Dn(l
, "dc=foo7"), ldb
.Dn(l
, "dc=bar"))
191 self
.assertEquals(len(l
.search()), 1)
193 l
.delete(ldb
.Dn(l
, "dc=bar"))
195 def test_rename_string_dns(self
):
196 l
= ldb
.Ldb(filename())
198 m
.dn
= ldb
.Dn(l
, "dc=foo8")
200 self
.assertEquals(len(l
.search()), 0)
202 self
.assertEquals(len(l
.search()), 1)
204 l
.rename("dc=foo8", "dc=bar")
205 self
.assertEquals(len(l
.search()), 1)
207 l
.delete(ldb
.Dn(l
, "dc=bar"))
209 def test_modify_delete(self
):
210 l
= ldb
.Ldb(filename())
212 m
.dn
= ldb
.Dn(l
, "dc=modifydelete")
215 rm
= l
.search(m
.dn
)[0]
216 self
.assertEquals(["1234"], list(rm
["bla"]))
219 m
.dn
= ldb
.Dn(l
, "dc=modifydelete")
220 m
["bla"] = ldb
.MessageElement([], ldb
.FLAG_MOD_DELETE
, "bla")
221 self
.assertEquals(ldb
.FLAG_MOD_DELETE
, m
["bla"].flags())
223 rm
= l
.search(m
.dn
)[0]
224 self
.assertEquals(1, len(rm
))
225 rm
= l
.search(m
.dn
, attrs
=["bla"])
226 self
.assertEquals(0, len(rm
))
228 l
.delete(ldb
.Dn(l
, "dc=modifydelete"))
230 def test_modify_add(self
):
231 l
= ldb
.Ldb(filename())
233 m
.dn
= ldb
.Dn(l
, "dc=add")
238 m
.dn
= ldb
.Dn(l
, "dc=add")
239 m
["bla"] = ldb
.MessageElement(["456"], ldb
.FLAG_MOD_ADD
, "bla")
240 self
.assertEquals(ldb
.FLAG_MOD_ADD
, m
["bla"].flags())
242 rm
= l
.search(m
.dn
)[0]
243 self
.assertEquals(2, len(rm
))
244 self
.assertEquals(["1234", "456"], list(rm
["bla"]))
246 l
.delete(ldb
.Dn(l
, "dc=add"))
248 def test_modify_replace(self
):
249 l
= ldb
.Ldb(filename())
251 m
.dn
= ldb
.Dn(l
, "dc=modify2")
252 m
["bla"] = ["1234", "456"]
256 m
.dn
= ldb
.Dn(l
, "dc=modify2")
257 m
["bla"] = ldb
.MessageElement(["789"], ldb
.FLAG_MOD_REPLACE
, "bla")
258 self
.assertEquals(ldb
.FLAG_MOD_REPLACE
, m
["bla"].flags())
260 rm
= l
.search(m
.dn
)[0]
261 self
.assertEquals(2, len(rm
))
262 self
.assertEquals(["789"], list(rm
["bla"]))
263 rm
= l
.search(m
.dn
, attrs
=["bla"])[0]
264 self
.assertEquals(1, len(rm
))
266 l
.delete(ldb
.Dn(l
, "dc=modify2"))
268 def test_modify_flags_change(self
):
269 l
= ldb
.Ldb(filename())
271 m
.dn
= ldb
.Dn(l
, "dc=add")
276 m
.dn
= ldb
.Dn(l
, "dc=add")
277 m
["bla"] = ldb
.MessageElement(["456"], ldb
.FLAG_MOD_ADD
, "bla")
278 self
.assertEquals(ldb
.FLAG_MOD_ADD
, m
["bla"].flags())
280 rm
= l
.search(m
.dn
)[0]
281 self
.assertEquals(2, len(rm
))
282 self
.assertEquals(["1234", "456"], list(rm
["bla"]))
284 # Now create another modify, but switch the flags before we do it
285 m
["bla"] = ldb
.MessageElement(["456"], ldb
.FLAG_MOD_ADD
, "bla")
286 m
["bla"].set_flags(ldb
.FLAG_MOD_DELETE
)
288 rm
= l
.search(m
.dn
, attrs
=["bla"])[0]
289 self
.assertEquals(1, len(rm
))
290 self
.assertEquals(["1234"], list(rm
["bla"]))
292 l
.delete(ldb
.Dn(l
, "dc=add"))
294 def test_transaction_commit(self
):
295 l
= ldb
.Ldb(filename())
296 l
.transaction_start()
297 m
= ldb
.Message(ldb
.Dn(l
, "dc=foo9"))
300 l
.transaction_commit()
303 def test_transaction_cancel(self
):
304 l
= ldb
.Ldb(filename())
305 l
.transaction_start()
306 m
= ldb
.Message(ldb
.Dn(l
, "dc=foo10"))
309 l
.transaction_cancel()
310 self
.assertEquals(0, len(l
.search(ldb
.Dn(l
, "dc=foo10"))))
312 def test_set_debug(self
):
313 def my_report_fn(level
, text
):
315 l
= ldb
.Ldb(filename())
316 l
.set_debug(my_report_fn
)
318 def test_zero_byte_string(self
):
319 """Testing we do not get trapped in the \0 byte in a property string."""
320 l
= ldb
.Ldb(filename())
323 "objectclass" : "user",
324 "cN" : "LDAPtestUSER",
325 "givenname" : "ldap",
326 "displayname" : "foo\0bar",
328 res
= l
.search(expression
="(dn=dc=somedn)")
329 self
.assertEquals("foo\0bar", res
[0]["displayname"][0])
331 def test_no_crash_broken_expr(self
):
332 l
= ldb
.Ldb(filename())
333 self
.assertRaises(ldb
.LdbError
,lambda: l
.search("", ldb
.SCOPE_SUBTREE
, "&(dc=*)(dn=*)", ["dc"]))
336 class DnTests(TestCase
):
339 super(DnTests
, self
).setUp()
340 self
.ldb
= ldb
.Ldb(filename())
342 def test_set_dn_invalid(self
):
346 self
.assertRaises(TypeError, assign
)
349 x
= ldb
.Dn(self
.ldb
, "dc=foo11,bar=bloe")
350 y
= ldb
.Dn(self
.ldb
, "dc=foo11,bar=bloe")
351 self
.assertEquals(x
, y
)
352 y
= ldb
.Dn(self
.ldb
, "dc=foo11,bar=blie")
353 self
.assertNotEquals(x
, y
)
356 x
= ldb
.Dn(self
.ldb
, "dc=foo12,bar=bloe")
357 self
.assertEquals(x
.__str
__(), "dc=foo12,bar=bloe")
360 x
= ldb
.Dn(self
.ldb
, "dc=foo13,bla=blie")
361 self
.assertEquals(x
.__repr
__(), "Dn('dc=foo13,bla=blie')")
363 def test_get_casefold(self
):
364 x
= ldb
.Dn(self
.ldb
, "dc=foo14,bar=bloe")
365 self
.assertEquals(x
.get_casefold(), "DC=FOO14,BAR=bloe")
367 def test_validate(self
):
368 x
= ldb
.Dn(self
.ldb
, "dc=foo15,bar=bloe")
369 self
.assertTrue(x
.validate())
371 def test_parent(self
):
372 x
= ldb
.Dn(self
.ldb
, "dc=foo16,bar=bloe")
373 self
.assertEquals("bar=bloe", x
.parent().__str
__())
375 def test_parent_nonexistent(self
):
376 x
= ldb
.Dn(self
.ldb
, "@BLA")
377 self
.assertEquals(None, x
.parent())
379 def test_is_valid(self
):
380 x
= ldb
.Dn(self
.ldb
, "dc=foo18,dc=bloe")
381 self
.assertTrue(x
.is_valid())
382 x
= ldb
.Dn(self
.ldb
, "")
383 self
.assertTrue(x
.is_valid())
385 def test_is_special(self
):
386 x
= ldb
.Dn(self
.ldb
, "dc=foo19,bar=bloe")
387 self
.assertFalse(x
.is_special())
388 x
= ldb
.Dn(self
.ldb
, "@FOOBAR")
389 self
.assertTrue(x
.is_special())
391 def test_check_special(self
):
392 x
= ldb
.Dn(self
.ldb
, "dc=foo20,bar=bloe")
393 self
.assertFalse(x
.check_special("FOOBAR"))
394 x
= ldb
.Dn(self
.ldb
, "@FOOBAR")
395 self
.assertTrue(x
.check_special("@FOOBAR"))
398 x
= ldb
.Dn(self
.ldb
, "dc=foo21,bar=bloe")
399 self
.assertEquals(2, len(x
))
400 x
= ldb
.Dn(self
.ldb
, "dc=foo21")
401 self
.assertEquals(1, len(x
))
403 def test_add_child(self
):
404 x
= ldb
.Dn(self
.ldb
, "dc=foo22,bar=bloe")
405 self
.assertTrue(x
.add_child(ldb
.Dn(self
.ldb
, "bla=bloe")))
406 self
.assertEquals("bla=bloe,dc=foo22,bar=bloe", x
.__str
__())
408 def test_add_base(self
):
409 x
= ldb
.Dn(self
.ldb
, "dc=foo23,bar=bloe")
410 base
= ldb
.Dn(self
.ldb
, "bla=bloe")
411 self
.assertTrue(x
.add_base(base
))
412 self
.assertEquals("dc=foo23,bar=bloe,bla=bloe", x
.__str
__())
415 x
= ldb
.Dn(self
.ldb
, "dc=foo24")
416 y
= ldb
.Dn(self
.ldb
, "bar=bla")
417 self
.assertEquals("dc=foo24,bar=bla", str(x
+ y
))
419 def test_remove_base_components(self
):
420 x
= ldb
.Dn(self
.ldb
, "dc=foo24,dc=samba,dc=org")
421 x
.remove_base_components(len(x
)-1)
422 self
.assertEquals("dc=foo24", str(x
))
424 def test_parse_ldif(self
):
425 msgs
= self
.ldb
.parse_ldif("dn: foo=bar\n")
427 self
.assertEquals("foo=bar", str(msg
[1].dn
))
428 self
.assertTrue(isinstance(msg
[1], ldb
.Message
))
429 ldif
= self
.ldb
.write_ldif(msg
[1], ldb
.CHANGETYPE_NONE
)
430 self
.assertEquals("dn: foo=bar\n\n", ldif
)
432 def test_parse_ldif_more(self
):
433 msgs
= self
.ldb
.parse_ldif("dn: foo=bar\n\n\ndn: bar=bar")
435 self
.assertEquals("foo=bar", str(msg
[1].dn
))
437 self
.assertEquals("bar=bar", str(msg
[1].dn
))
439 def test_canonical_string(self
):
440 x
= ldb
.Dn(self
.ldb
, "dc=foo25,bar=bloe")
441 self
.assertEquals("/bloe/foo25", x
.canonical_str())
443 def test_canonical_ex_string(self
):
444 x
= ldb
.Dn(self
.ldb
, "dc=foo26,bar=bloe")
445 self
.assertEquals("/bloe\nfoo26", x
.canonical_ex_str())
447 def test_ldb_is_child_of(self
):
448 """Testing ldb_dn_compare_dn"""
449 dn1
= ldb
.Dn(self
.ldb
, "dc=base")
450 dn2
= ldb
.Dn(self
.ldb
, "cn=foo,dc=base")
451 dn3
= ldb
.Dn(self
.ldb
, "cn=bar,dc=base")
452 dn4
= ldb
.Dn(self
.ldb
, "cn=baz,cn=bar,dc=base")
454 self
.assertTrue(dn2
.is_child_of(dn1
))
455 self
.assertTrue(dn4
.is_child_of(dn1
))
456 self
.assertTrue(dn4
.is_child_of(dn3
))
457 self
.assertFalse(dn3
.is_child_of(dn2
))
458 self
.assertFalse(dn1
.is_child_of(dn4
))
460 class LdbMsgTests(TestCase
):
463 super(LdbMsgTests
, self
).setUp()
464 self
.msg
= ldb
.Message()
466 def test_init_dn(self
):
467 self
.msg
= ldb
.Message(ldb
.Dn(ldb
.Ldb(), "dc=foo27"))
468 self
.assertEquals("dc=foo27", str(self
.msg
.dn
))
470 def test_iter_items(self
):
471 self
.assertEquals(0, len(self
.msg
.items()))
472 self
.msg
.dn
= ldb
.Dn(ldb
.Ldb(filename()), "dc=foo28")
473 self
.assertEquals(1, len(self
.msg
.items()))
476 self
.msg
.dn
= ldb
.Dn(ldb
.Ldb(filename()), "dc=foo29")
477 self
.msg
["dc"] = "foo"
478 self
.assertEquals("Message({'dn': Dn('dc=foo29'), 'dc': MessageElement(['foo'])})", repr(self
.msg
))
481 self
.assertEquals(0, len(self
.msg
))
483 def test_notpresent(self
):
484 self
.assertRaises(KeyError, lambda: self
.msg
["foo"])
490 self
.msg
.add(ldb
.MessageElement(["456"], ldb
.FLAG_MOD_ADD
, "bla"))
492 def test_elements_empty(self
):
493 self
.assertEquals([], self
.msg
.elements())
495 def test_elements(self
):
496 el
= ldb
.MessageElement(["456"], ldb
.FLAG_MOD_ADD
, "bla")
498 self
.assertEquals([el
], self
.msg
.elements())
500 def test_add_value(self
):
501 self
.assertEquals(0, len(self
.msg
))
502 self
.msg
["foo"] = ["foo"]
503 self
.assertEquals(1, len(self
.msg
))
505 def test_add_value_multiple(self
):
506 self
.assertEquals(0, len(self
.msg
))
507 self
.msg
["foo"] = ["foo", "bla"]
508 self
.assertEquals(1, len(self
.msg
))
509 self
.assertEquals(["foo", "bla"], list(self
.msg
["foo"]))
511 def test_set_value(self
):
512 self
.msg
["foo"] = ["fool"]
513 self
.assertEquals(["fool"], list(self
.msg
["foo"]))
514 self
.msg
["foo"] = ["bar"]
515 self
.assertEquals(["bar"], list(self
.msg
["foo"]))
518 self
.msg
.dn
= ldb
.Dn(ldb
.Ldb(filename()), "@BASEINFO")
519 self
.msg
["foo"] = ["bla"]
520 self
.msg
["bar"] = ["bla"]
521 self
.assertEquals(["dn", "foo", "bar"], self
.msg
.keys())
524 self
.msg
.dn
= ldb
.Dn(ldb
.Ldb(filename()), "@BASEINFO")
525 self
.assertEquals("@BASEINFO", self
.msg
.dn
.__str
__())
527 def test_get_dn(self
):
528 self
.msg
.dn
= ldb
.Dn(ldb
.Ldb(filename()), "@BASEINFO")
529 self
.assertEquals("@BASEINFO", self
.msg
.get("dn").__str
__())
531 def test_get_invalid(self
):
532 self
.msg
.dn
= ldb
.Dn(ldb
.Ldb(filename()), "@BASEINFO")
533 self
.assertRaises(TypeError, self
.msg
.get
, 42)
535 def test_get_other(self
):
536 self
.msg
["foo"] = ["bar"]
537 self
.assertEquals("bar", self
.msg
.get("foo")[0])
538 self
.assertEquals("bar", self
.msg
.get("foo", idx
=0))
539 self
.assertEquals(None, self
.msg
.get("foo", idx
=1))
540 self
.assertEquals("", self
.msg
.get("foo", default
='', idx
=1))
542 def test_get_default(self
):
543 self
.assertEquals(None, self
.msg
.get("tatayoyo", idx
=0))
544 self
.assertEquals("anniecordie", self
.msg
.get("tatayoyo", "anniecordie"))
546 def test_get_unknown(self
):
547 self
.assertEquals(None, self
.msg
.get("lalalala"))
549 def test_msg_diff(self
):
551 msgs
= l
.parse_ldif("dn: foo=bar\nfoo: bar\nbaz: do\n\ndn: foo=bar\nfoo: bar\nbaz: dont\n")
552 msg1
= msgs
.next()[1]
553 msg2
= msgs
.next()[1]
554 msgdiff
= l
.msg_diff(msg1
, msg2
)
555 self
.assertEquals("foo=bar", msgdiff
.get("dn").__str
__())
556 self
.assertRaises(KeyError, lambda: msgdiff
["foo"])
557 self
.assertEquals(1, len(msgdiff
))
559 def test_equal_empty(self
):
562 self
.assertEquals(msg1
, msg2
)
564 def test_equal_simplel(self
):
565 db
= ldb
.Ldb(filename())
567 msg1
.dn
= ldb
.Dn(db
, "foo=bar")
569 msg2
.dn
= ldb
.Dn(db
, "foo=bar")
570 self
.assertEquals(msg1
, msg2
)
573 self
.assertEquals(msg1
, msg2
)
575 self
.assertNotEquals(msg1
, msg2
)
578 def test_from_dict(self
):
579 rec
= {"dn": "dc=fromdict",
580 "a1": ["a1-val1", "a1-val1"]}
582 # check different types of input Flags
583 for flags
in [ldb
.FLAG_MOD_ADD
, ldb
.FLAG_MOD_REPLACE
, ldb
.FLAG_MOD_DELETE
]:
584 m
= ldb
.Message
.from_dict(l
, rec
, flags
)
585 self
.assertEquals(rec
["a1"], list(m
["a1"]))
586 self
.assertEquals(flags
, m
["a1"].flags())
588 self
.assertRaises(TypeError, ldb
.Message
.from_dict
, dict(), rec
, ldb
.FLAG_MOD_REPLACE
)
589 self
.assertRaises(TypeError, ldb
.Message
.from_dict
, l
, list(), ldb
.FLAG_MOD_REPLACE
)
590 self
.assertRaises(ValueError, ldb
.Message
.from_dict
, l
, rec
, 0)
591 # Message.from_dict expects dictionary with 'dn'
592 err_rec
= {"a1": ["a1-val1", "a1-val1"]}
593 self
.assertRaises(TypeError, ldb
.Message
.from_dict
, l
, err_rec
, ldb
.FLAG_MOD_REPLACE
)
595 def test_copy_add_message_element(self
):
597 m
["1"] = ldb
.MessageElement(["val 111"], ldb
.FLAG_MOD_ADD
, "1")
598 m
["2"] = ldb
.MessageElement(["val 222"], ldb
.FLAG_MOD_ADD
, "2")
602 self
.assertEqual(mto
["1"], m
["1"])
603 self
.assertEqual(mto
["2"], m
["2"])
607 self
.assertEqual(mto
["1"], m
["1"])
608 self
.assertEqual(mto
["2"], m
["2"])
611 class MessageElementTests(TestCase
):
613 def test_cmp_element(self
):
614 x
= ldb
.MessageElement(["foo"])
615 y
= ldb
.MessageElement(["foo"])
616 z
= ldb
.MessageElement(["bzr"])
617 self
.assertEquals(x
, y
)
618 self
.assertNotEquals(x
, z
)
620 def test_create_iterable(self
):
621 x
= ldb
.MessageElement(["foo"])
622 self
.assertEquals(["foo"], list(x
))
625 x
= ldb
.MessageElement(["foo"])
626 self
.assertEquals("MessageElement(['foo'])", repr(x
))
627 x
= ldb
.MessageElement(["foo", "bla"])
628 self
.assertEquals(2, len(x
))
629 self
.assertEquals("MessageElement(['foo','bla'])", repr(x
))
631 def test_get_item(self
):
632 x
= ldb
.MessageElement(["foo", "bar"])
633 self
.assertEquals("foo", x
[0])
634 self
.assertEquals("bar", x
[1])
635 self
.assertEquals("bar", x
[-1])
636 self
.assertRaises(IndexError, lambda: x
[45])
639 x
= ldb
.MessageElement(["foo", "bar"])
640 self
.assertEquals(2, len(x
))
643 x
= ldb
.MessageElement(["foo", "bar"])
644 y
= ldb
.MessageElement(["foo", "bar"])
645 self
.assertEquals(y
, x
)
646 x
= ldb
.MessageElement(["foo"])
647 self
.assertNotEquals(y
, x
)
648 y
= ldb
.MessageElement(["foo"])
649 self
.assertEquals(y
, x
)
651 def test_extended(self
):
652 el
= ldb
.MessageElement(["456"], ldb
.FLAG_MOD_ADD
, "bla")
653 self
.assertEquals("MessageElement(['456'])", repr(el
))
656 class ModuleTests(TestCase
):
658 def test_register_module(self
):
661 ldb
.register_module(ExampleModule
)
663 def test_use_module(self
):
668 def __init__(self
, ldb
, next
):
672 def search(self
, *args
, **kwargs
):
673 return self
.next
.search(*args
, **kwargs
)
675 def request(self
, *args
, **kwargs
):
679 ldb
.register_module(ExampleModule
)
680 if os
.path
.exists(name
):
683 l
.add({"dn": "@MODULES", "@LIST": "bla"})
684 self
.assertEquals([], ops
)
686 self
.assertEquals(["init"], ops
)
688 class LdbResultTests(TestCase
):
691 super(LdbResultTests
, self
).setUp()
694 if os
.path
.exists(name
):
696 self
.l
= ldb
.Ldb(name
)
697 self
.l
.add({"dn": "DC=SAMBA,DC=ORG", "name": "samba.org"})
698 self
.l
.add({"dn": "OU=ADMIN,DC=SAMBA,DC=ORG", "name": "Admins"})
699 self
.l
.add({"dn": "OU=USERS,DC=SAMBA,DC=ORG", "name": "Users"})
700 self
.l
.add({"dn": "OU=OU1,DC=SAMBA,DC=ORG", "name": "OU #1"})
701 self
.l
.add({"dn": "OU=OU2,DC=SAMBA,DC=ORG", "name": "OU #2"})
702 self
.l
.add({"dn": "OU=OU3,DC=SAMBA,DC=ORG", "name": "OU #3"})
703 self
.l
.add({"dn": "OU=OU4,DC=SAMBA,DC=ORG", "name": "OU #4"})
704 self
.l
.add({"dn": "OU=OU5,DC=SAMBA,DC=ORG", "name": "OU #5"})
705 self
.l
.add({"dn": "OU=OU6,DC=SAMBA,DC=ORG", "name": "OU #6"})
706 self
.l
.add({"dn": "OU=OU7,DC=SAMBA,DC=ORG", "name": "OU #7"})
707 self
.l
.add({"dn": "OU=OU8,DC=SAMBA,DC=ORG", "name": "OU #8"})
708 self
.l
.add({"dn": "OU=OU9,DC=SAMBA,DC=ORG", "name": "OU #9"})
709 self
.l
.add({"dn": "OU=OU10,DC=SAMBA,DC=ORG", "name": "OU #10"})
712 super(LdbResultTests
, self
).tearDown()
713 if os
.path
.exists(self
.name
):
716 def test_return_type(self
):
717 res
= self
.l
.search()
718 self
.assertEquals(str(res
), "<ldb result>")
720 def test_get_msgs(self
):
721 res
= self
.l
.search()
724 def test_get_controls(self
):
725 res
= self
.l
.search()
728 def test_get_referals(self
):
729 res
= self
.l
.search()
732 def test_iter_msgs(self
):
734 for l
in self
.l
.search().msgs
:
735 if str(l
.dn
) == "OU=OU10,DC=SAMBA,DC=ORG":
737 self
.assertTrue(found
)
739 def test_iter_msgs_count(self
):
740 self
.assertTrue(self
.l
.search().count
> 0)
741 # 13 objects has been added to the DC=SAMBA, DC=ORG
742 self
.assertEqual(self
.l
.search(base
="DC=SAMBA,DC=ORG").count
, 13)
744 def test_iter_controls(self
):
745 res
= self
.l
.search().controls
748 def test_create_control(self
):
749 self
.assertRaises(ValueError, ldb
.Control
, self
.l
, "tatayoyo:0")
750 c
= ldb
.Control(self
.l
, "relax:1")
751 self
.assertEquals(c
.critical
, True)
752 self
.assertEquals(c
.oid
, "1.3.6.1.4.1.4203.666.5.12")
754 def test_iter_refs(self
):
755 res
= self
.l
.search().referals
758 def test_iter_as_sequence_msgs(self
):
760 res
= self
.l
.search().msgs
762 for i
in range(0, len(res
)):
764 if str(l
.dn
) == "OU=OU10,DC=SAMBA,DC=ORG":
766 self
.assertTrue(found
)
768 def test_iter_as_sequence(self
):
770 res
= self
.l
.search()
772 for i
in range(0, len(res
)):
774 if str(l
.dn
) == "OU=OU10,DC=SAMBA,DC=ORG":
776 self
.assertTrue(found
)
779 class BadTypeTests(TestCase
):
780 def test_control(self
):
782 self
.assertRaises(TypeError, ldb
.Control
, '<bad type>', 'relax:1')
783 self
.assertRaises(TypeError, ldb
.Control
, ldb
, 1234)
785 def test_modify(self
):
787 dn
= ldb
.Dn(l
, 'a=b')
789 self
.assertRaises(TypeError, l
.modify
, '<bad type>')
790 self
.assertRaises(TypeError, l
.modify
, m
, '<bad type>')
794 dn
= ldb
.Dn(l
, 'a=b')
796 self
.assertRaises(TypeError, l
.add
, '<bad type>')
797 self
.assertRaises(TypeError, l
.add
, m
, '<bad type>')
799 def test_delete(self
):
801 dn
= ldb
.Dn(l
, 'a=b')
802 self
.assertRaises(TypeError, l
.add
, '<bad type>')
803 self
.assertRaises(TypeError, l
.add
, dn
, '<bad type>')
805 def test_rename(self
):
807 dn
= ldb
.Dn(l
, 'a=b')
808 self
.assertRaises(TypeError, l
.add
, '<bad type>', dn
)
809 self
.assertRaises(TypeError, l
.add
, dn
, '<bad type>')
810 self
.assertRaises(TypeError, l
.add
, dn
, dn
, '<bad type>')
812 def test_search(self
):
814 self
.assertRaises(TypeError, l
.search
, base
=1234)
815 self
.assertRaises(TypeError, l
.search
, scope
='<bad type>')
816 self
.assertRaises(TypeError, l
.search
, expression
=1234)
817 self
.assertRaises(TypeError, l
.search
, attrs
='<bad type>')
818 self
.assertRaises(TypeError, l
.search
, controls
='<bad type>')
821 class VersionTests(TestCase
):
823 def test_version(self
):
824 self
.assertTrue(isinstance(ldb
.__version
__, str))
827 if __name__
== '__main__':
829 unittest
.TestProgram()