2 # Simple tests for the ldb python bindings.
3 # Copyright (C) 2007 Jelmer Vernooij <jelmer@samba.org>
14 dir_prefix
= os
.path
.join(os
.environ
["SELFTEST_PREFIX"], "tmp")
17 return tempfile
.mktemp(dir=dir_prefix
)
19 class NoContextTests(unittest
.TestCase
):
21 def test_valid_attr_name(self
):
22 self
.assertTrue(ldb
.valid_attr_name("foo"))
23 self
.assertFalse(ldb
.valid_attr_name("24foo"))
25 def test_timestring(self
):
26 self
.assertEquals("19700101000000.0Z", ldb
.timestring(0))
27 self
.assertEquals("20071119191012.0Z", ldb
.timestring(1195499412))
29 def test_string_to_time(self
):
30 self
.assertEquals(0, ldb
.string_to_time("19700101000000.0Z"))
31 self
.assertEquals(1195499412, ldb
.string_to_time("20071119191012.0Z"))
34 class SimpleLdb(unittest
.TestCase
):
36 def test_connect(self
):
39 def test_connect_none(self
):
42 def test_connect_later(self
):
48 self
.assertTrue(repr(x
).startswith("<ldb connection"))
50 def test_set_create_perms(self
):
52 x
.set_create_perms(0600)
54 def test_set_modules_dir(self
):
56 x
.set_modules_dir("/tmp")
58 def test_modules_none(self
):
60 self
.assertEquals([], x
.modules())
62 def test_modules_tdb(self
):
63 x
= ldb
.Ldb(filename())
64 self
.assertEquals("[<ldb module 'tdb'>]", repr(x
.modules()))
66 def test_search(self
):
67 l
= ldb
.Ldb(filename())
68 self
.assertEquals(len(l
.search()), 1)
70 def test_search_controls(self
):
71 l
= ldb
.Ldb(filename())
72 self
.assertEquals(len(l
.search(controls
=["paged_results:0:5"])), 1)
74 def test_search_attrs(self
):
75 l
= ldb
.Ldb(filename())
76 self
.assertEquals(len(l
.search(ldb
.Dn(l
, ""), ldb
.SCOPE_SUBTREE
, "(dc=*)", ["dc"])), 0)
78 def test_search_string_dn(self
):
79 l
= ldb
.Ldb(filename())
80 self
.assertEquals(len(l
.search("", ldb
.SCOPE_SUBTREE
, "(dc=*)", ["dc"])), 0)
82 def test_search_attr_string(self
):
83 l
= ldb
.Ldb(filename())
84 self
.assertRaises(TypeError, l
.search
, attrs
="dc")
86 def test_opaque(self
):
87 l
= ldb
.Ldb(filename())
88 l
.set_opaque("my_opaque", l
)
89 self
.assertTrue(l
.get_opaque("my_opaque") is not None)
90 self
.assertEquals(None, l
.get_opaque("unknown"))
92 def test_search_scope_base(self
):
93 l
= ldb
.Ldb(filename())
94 self
.assertEquals(len(l
.search(ldb
.Dn(l
, "dc=foo1"),
95 ldb
.SCOPE_ONELEVEL
)), 0)
97 def test_delete(self
):
98 l
= ldb
.Ldb(filename())
99 self
.assertRaises(ldb
.LdbError
, lambda: l
.delete(ldb
.Dn(l
, "dc=foo2")))
101 def test_delete_w_unhandled_ctrl(self
):
102 l
= ldb
.Ldb(filename())
104 m
.dn
= ldb
.Dn(l
, "dc=foo1")
107 self
.assertRaises(ldb
.LdbError
, lambda: l
.delete(m
.dn
, ["search_options:1:2"]))
110 def test_contains(self
):
113 self
.assertFalse(ldb
.Dn(l
, "dc=foo3") in l
)
116 m
.dn
= ldb
.Dn(l
, "dc=foo3")
120 self
.assertTrue(ldb
.Dn(l
, "dc=foo3") in l
)
124 def test_get_config_basedn(self
):
125 l
= ldb
.Ldb(filename())
126 self
.assertEquals(None, l
.get_config_basedn())
128 def test_get_root_basedn(self
):
129 l
= ldb
.Ldb(filename())
130 self
.assertEquals(None, l
.get_root_basedn())
132 def test_get_schema_basedn(self
):
133 l
= ldb
.Ldb(filename())
134 self
.assertEquals(None, l
.get_schema_basedn())
136 def test_get_default_basedn(self
):
137 l
= ldb
.Ldb(filename())
138 self
.assertEquals(None, l
.get_default_basedn())
141 l
= ldb
.Ldb(filename())
143 m
.dn
= ldb
.Dn(l
, "dc=foo4")
145 self
.assertEquals(len(l
.search()), 1)
148 self
.assertEquals(len(l
.search()), 2)
150 l
.delete(ldb
.Dn(l
, "dc=foo4"))
152 def test_add_w_unhandled_ctrl(self
):
153 l
= ldb
.Ldb(filename())
155 m
.dn
= ldb
.Dn(l
, "dc=foo4")
157 self
.assertEquals(len(l
.search()), 1)
158 self
.assertRaises(ldb
.LdbError
, lambda: l
.add(m
,["search_options:1:2"]))
160 def test_add_dict(self
):
161 l
= ldb
.Ldb(filename())
162 m
= {"dn": ldb
.Dn(l
, "dc=foo5"),
164 self
.assertEquals(len(l
.search()), 1)
167 self
.assertEquals(len(l
.search()), 2)
169 l
.delete(ldb
.Dn(l
, "dc=foo5"))
171 def test_add_dict_string_dn(self
):
172 l
= ldb
.Ldb(filename())
173 m
= {"dn": "dc=foo6", "bla": "bla"}
174 self
.assertEquals(len(l
.search()), 1)
177 self
.assertEquals(len(l
.search()), 2)
179 l
.delete(ldb
.Dn(l
, "dc=foo6"))
181 def test_rename(self
):
182 l
= ldb
.Ldb(filename())
184 m
.dn
= ldb
.Dn(l
, "dc=foo7")
186 self
.assertEquals(len(l
.search()), 1)
189 l
.rename(ldb
.Dn(l
, "dc=foo7"), ldb
.Dn(l
, "dc=bar"))
190 self
.assertEquals(len(l
.search()), 2)
192 l
.delete(ldb
.Dn(l
, "dc=bar"))
194 def test_rename_string_dns(self
):
195 l
= ldb
.Ldb(filename())
197 m
.dn
= ldb
.Dn(l
, "dc=foo8")
199 self
.assertEquals(len(l
.search()), 1)
201 self
.assertEquals(len(l
.search()), 2)
203 l
.rename("dc=foo8", "dc=bar")
204 self
.assertEquals(len(l
.search()), 2)
206 l
.delete(ldb
.Dn(l
, "dc=bar"))
208 def test_modify_delete(self
):
209 l
= ldb
.Ldb(filename())
211 m
.dn
= ldb
.Dn(l
, "dc=modifydelete")
214 rm
= l
.search(m
.dn
)[0]
215 self
.assertEquals(["1234"], list(rm
["bla"]))
218 m
.dn
= ldb
.Dn(l
, "dc=modifydelete")
219 m
["bla"] = ldb
.MessageElement([], ldb
.FLAG_MOD_DELETE
, "bla")
220 self
.assertEquals(ldb
.FLAG_MOD_DELETE
, m
["bla"].flags())
222 rm
= l
.search(m
.dn
)[0]
223 self
.assertEquals(1, len(rm
))
224 rm
= l
.search(m
.dn
, attrs
=["bla"])
225 self
.assertEquals(0, len(rm
))
227 l
.delete(ldb
.Dn(l
, "dc=modifydelete"))
229 def test_modify_add(self
):
230 l
= ldb
.Ldb(filename())
232 m
.dn
= ldb
.Dn(l
, "dc=add")
237 m
.dn
= ldb
.Dn(l
, "dc=add")
238 m
["bla"] = ldb
.MessageElement(["456"], ldb
.FLAG_MOD_ADD
, "bla")
239 self
.assertEquals(ldb
.FLAG_MOD_ADD
, m
["bla"].flags())
241 rm
= l
.search(m
.dn
)[0]
242 self
.assertEquals(2, len(rm
))
243 self
.assertEquals(["1234", "456"], list(rm
["bla"]))
245 l
.delete(ldb
.Dn(l
, "dc=add"))
247 def test_modify_replace(self
):
248 l
= ldb
.Ldb(filename())
250 m
.dn
= ldb
.Dn(l
, "dc=modify2")
251 m
["bla"] = ["1234", "456"]
255 m
.dn
= ldb
.Dn(l
, "dc=modify2")
256 m
["bla"] = ldb
.MessageElement(["789"], ldb
.FLAG_MOD_REPLACE
, "bla")
257 self
.assertEquals(ldb
.FLAG_MOD_REPLACE
, m
["bla"].flags())
259 rm
= l
.search(m
.dn
)[0]
260 self
.assertEquals(2, len(rm
))
261 self
.assertEquals(["789"], list(rm
["bla"]))
262 rm
= l
.search(m
.dn
, attrs
=["bla"])[0]
263 self
.assertEquals(1, len(rm
))
265 l
.delete(ldb
.Dn(l
, "dc=modify2"))
267 def test_modify_flags_change(self
):
268 l
= ldb
.Ldb(filename())
270 m
.dn
= ldb
.Dn(l
, "dc=add")
275 m
.dn
= ldb
.Dn(l
, "dc=add")
276 m
["bla"] = ldb
.MessageElement(["456"], ldb
.FLAG_MOD_ADD
, "bla")
277 self
.assertEquals(ldb
.FLAG_MOD_ADD
, m
["bla"].flags())
279 rm
= l
.search(m
.dn
)[0]
280 self
.assertEquals(2, len(rm
))
281 self
.assertEquals(["1234", "456"], list(rm
["bla"]))
283 # Now create another modify, but switch the flags before we do it
284 m
["bla"] = ldb
.MessageElement(["456"], ldb
.FLAG_MOD_ADD
, "bla")
285 m
["bla"].set_flags(ldb
.FLAG_MOD_DELETE
)
287 rm
= l
.search(m
.dn
, attrs
=["bla"])[0]
288 self
.assertEquals(1, len(rm
))
289 self
.assertEquals(["1234"], list(rm
["bla"]))
291 l
.delete(ldb
.Dn(l
, "dc=add"))
293 def test_transaction_commit(self
):
294 l
= ldb
.Ldb(filename())
295 l
.transaction_start()
296 m
= ldb
.Message(ldb
.Dn(l
, "dc=foo9"))
299 l
.transaction_commit()
302 def test_transaction_cancel(self
):
303 l
= ldb
.Ldb(filename())
304 l
.transaction_start()
305 m
= ldb
.Message(ldb
.Dn(l
, "dc=foo10"))
308 l
.transaction_cancel()
309 self
.assertEquals(0, len(l
.search(ldb
.Dn(l
, "dc=foo10"))))
311 def test_set_debug(self
):
312 def my_report_fn(level
, text
):
314 l
= ldb
.Ldb(filename())
315 l
.set_debug(my_report_fn
)
317 def test_zero_byte_string(self
):
318 """Testing we do not get trapped in the \0 byte in a property string."""
319 l
= ldb
.Ldb(filename())
322 "objectclass" : "user",
323 "cN" : "LDAPtestUSER",
324 "givenname" : "ldap",
325 "displayname" : "foo\0bar",
327 res
= l
.search(expression
="(dn=dc=somedn)")
328 self
.assertEquals("foo\0bar", res
[0]["displayname"][0])
330 def test_no_crash_broken_expr(self
):
331 l
= ldb
.Ldb(filename())
332 self
.assertRaises(ldb
.LdbError
,lambda: l
.search("", ldb
.SCOPE_SUBTREE
, "&(dc=*)(dn=*)", ["dc"]))
335 class DnTests(unittest
.TestCase
):
338 self
.ldb
= ldb
.Ldb(filename())
340 def test_set_dn_invalid(self
):
344 self
.assertRaises(TypeError, assign
)
347 x
= ldb
.Dn(self
.ldb
, "dc=foo11,bar=bloe")
348 y
= ldb
.Dn(self
.ldb
, "dc=foo11,bar=bloe")
349 self
.assertEquals(x
, y
)
350 y
= ldb
.Dn(self
.ldb
, "dc=foo11,bar=blie")
351 self
.assertNotEquals(x
, y
)
354 x
= ldb
.Dn(self
.ldb
, "dc=foo12,bar=bloe")
355 self
.assertEquals(x
.__str
__(), "dc=foo12,bar=bloe")
358 x
= ldb
.Dn(self
.ldb
, "dc=foo13,bla=blie")
359 self
.assertEquals(x
.__repr
__(), "Dn('dc=foo13,bla=blie')")
361 def test_get_casefold(self
):
362 x
= ldb
.Dn(self
.ldb
, "dc=foo14,bar=bloe")
363 self
.assertEquals(x
.get_casefold(), "DC=FOO14,BAR=bloe")
365 def test_validate(self
):
366 x
= ldb
.Dn(self
.ldb
, "dc=foo15,bar=bloe")
367 self
.assertTrue(x
.validate())
369 def test_parent(self
):
370 x
= ldb
.Dn(self
.ldb
, "dc=foo16,bar=bloe")
371 self
.assertEquals("bar=bloe", x
.parent().__str
__())
373 def test_parent_nonexistant(self
):
374 x
= ldb
.Dn(self
.ldb
, "@BLA")
375 self
.assertEquals(None, x
.parent())
377 def test_is_valid(self
):
378 x
= ldb
.Dn(self
.ldb
, "dc=foo18,dc=bloe")
379 self
.assertTrue(x
.is_valid())
380 x
= ldb
.Dn(self
.ldb
, "")
381 self
.assertTrue(x
.is_valid())
383 def test_is_special(self
):
384 x
= ldb
.Dn(self
.ldb
, "dc=foo19,bar=bloe")
385 self
.assertFalse(x
.is_special())
386 x
= ldb
.Dn(self
.ldb
, "@FOOBAR")
387 self
.assertTrue(x
.is_special())
389 def test_check_special(self
):
390 x
= ldb
.Dn(self
.ldb
, "dc=foo20,bar=bloe")
391 self
.assertFalse(x
.check_special("FOOBAR"))
392 x
= ldb
.Dn(self
.ldb
, "@FOOBAR")
393 self
.assertTrue(x
.check_special("@FOOBAR"))
396 x
= ldb
.Dn(self
.ldb
, "dc=foo21,bar=bloe")
397 self
.assertEquals(2, len(x
))
398 x
= ldb
.Dn(self
.ldb
, "dc=foo21")
399 self
.assertEquals(1, len(x
))
401 def test_add_child(self
):
402 x
= ldb
.Dn(self
.ldb
, "dc=foo22,bar=bloe")
403 self
.assertTrue(x
.add_child(ldb
.Dn(self
.ldb
, "bla=bloe")))
404 self
.assertEquals("bla=bloe,dc=foo22,bar=bloe", x
.__str
__())
406 def test_add_base(self
):
407 x
= ldb
.Dn(self
.ldb
, "dc=foo23,bar=bloe")
408 base
= ldb
.Dn(self
.ldb
, "bla=bloe")
409 self
.assertTrue(x
.add_base(base
))
410 self
.assertEquals("dc=foo23,bar=bloe,bla=bloe", x
.__str
__())
413 x
= ldb
.Dn(self
.ldb
, "dc=foo24")
414 y
= ldb
.Dn(self
.ldb
, "bar=bla")
415 self
.assertEquals("dc=foo24,bar=bla", str(y
+ x
))
417 def test_parse_ldif(self
):
418 msgs
= self
.ldb
.parse_ldif("dn: foo=bar\n")
420 self
.assertEquals("foo=bar", str(msg
[1].dn
))
421 self
.assertTrue(isinstance(msg
[1], ldb
.Message
))
422 ldif
= self
.ldb
.write_ldif(msg
[1], ldb
.CHANGETYPE_NONE
)
423 self
.assertEquals("dn: foo=bar\n\n", ldif
)
425 def test_parse_ldif_more(self
):
426 msgs
= self
.ldb
.parse_ldif("dn: foo=bar\n\n\ndn: bar=bar")
428 self
.assertEquals("foo=bar", str(msg
[1].dn
))
430 self
.assertEquals("bar=bar", str(msg
[1].dn
))
432 def test_canonical_string(self
):
433 x
= ldb
.Dn(self
.ldb
, "dc=foo25,bar=bloe")
434 self
.assertEquals("/bloe/foo25", x
.canonical_str())
436 def test_canonical_ex_string(self
):
437 x
= ldb
.Dn(self
.ldb
, "dc=foo26,bar=bloe")
438 self
.assertEquals("/bloe\nfoo26", x
.canonical_ex_str())
440 def test_ldb_base_compare(self
):
441 """Testing ldb_dn_compare_dn"""
442 dn1
= ldb
.Dn(self
.ldb
, "dc=base")
443 dn2
= ldb
.Dn(self
.ldb
, "cn=foo,dc=base")
444 dn3
= ldb
.Dn(self
.ldb
, "cn=bar,dc=base")
445 dn4
= ldb
.Dn(self
.ldb
, "cn=baz,cn=bar,dc=base")
447 self
.assertEquals(0, dn2
.compare_base(dn1
))
448 self
.assertEquals(0, dn4
.compare_base(dn1
))
449 self
.assertEquals(0, dn4
.compare_base(dn3
))
450 self
.assertFalse(dn3
.compare_base(dn2
) == 0)
452 class LdbMsgTests(unittest
.TestCase
):
455 self
.msg
= ldb
.Message()
457 def test_init_dn(self
):
458 self
.msg
= ldb
.Message(ldb
.Dn(ldb
.Ldb(), "dc=foo27"))
459 self
.assertEquals("dc=foo27", str(self
.msg
.dn
))
461 def test_iter_items(self
):
462 self
.assertEquals(0, len(self
.msg
.items()))
463 self
.msg
.dn
= ldb
.Dn(ldb
.Ldb(filename()), "dc=foo28")
464 self
.assertEquals(1, len(self
.msg
.items()))
467 self
.msg
.dn
= ldb
.Dn(ldb
.Ldb(filename()), "dc=foo29")
468 self
.msg
["dc"] = "foo"
469 self
.assertEquals("Message({'dn': Dn('dc=foo29'), 'dc': MessageElement(['foo'])})", repr(self
.msg
))
472 self
.assertEquals(0, len(self
.msg
))
474 def test_notpresent(self
):
475 self
.assertRaises(KeyError, lambda: self
.msg
["foo"])
481 self
.msg
.add(ldb
.MessageElement(["456"], ldb
.FLAG_MOD_ADD
, "bla"))
483 def test_elements_empty(self
):
484 self
.assertEquals([], self
.msg
.elements())
486 def test_elements(self
):
487 el
= ldb
.MessageElement(["456"], ldb
.FLAG_MOD_ADD
, "bla")
489 self
.assertEquals([el
], self
.msg
.elements())
491 def test_add_value(self
):
492 self
.assertEquals(0, len(self
.msg
))
493 self
.msg
["foo"] = ["foo"]
494 self
.assertEquals(1, len(self
.msg
))
496 def test_add_value_multiple(self
):
497 self
.assertEquals(0, len(self
.msg
))
498 self
.msg
["foo"] = ["foo", "bla"]
499 self
.assertEquals(1, len(self
.msg
))
500 self
.assertEquals(["foo", "bla"], list(self
.msg
["foo"]))
502 def test_set_value(self
):
503 self
.msg
["foo"] = ["fool"]
504 self
.assertEquals(["fool"], list(self
.msg
["foo"]))
505 self
.msg
["foo"] = ["bar"]
506 self
.assertEquals(["bar"], list(self
.msg
["foo"]))
509 self
.msg
.dn
= ldb
.Dn(ldb
.Ldb(filename()), "@BASEINFO")
510 self
.msg
["foo"] = ["bla"]
511 self
.msg
["bar"] = ["bla"]
512 self
.assertEquals(["dn", "foo", "bar"], self
.msg
.keys())
515 self
.msg
.dn
= ldb
.Dn(ldb
.Ldb(filename()), "@BASEINFO")
516 self
.assertEquals("@BASEINFO", self
.msg
.dn
.__str
__())
518 def test_get_dn(self
):
519 self
.msg
.dn
= ldb
.Dn(ldb
.Ldb(filename()), "@BASEINFO")
520 self
.assertEquals("@BASEINFO", self
.msg
.get("dn").__str
__())
522 def test_get_invalid(self
):
523 self
.msg
.dn
= ldb
.Dn(ldb
.Ldb(filename()), "@BASEINFO")
524 self
.assertRaises(TypeError, self
.msg
.get
, 42)
526 def test_get_other(self
):
527 self
.msg
["foo"] = ["bar"]
528 self
.assertEquals("bar", self
.msg
.get("foo")[0])
530 def test_get_default(self
):
531 self
.assertEquals(None, self
.msg
.get("tatayoyo"))
533 self
.assertEquals("anniecordie", self
.msg
.get("tatayoyo", "anniecordie"))
535 def test_get_unknown(self
):
536 self
.assertEquals(None, self
.msg
.get("lalalala"))
538 def test_msg_diff(self
):
540 msgs
= l
.parse_ldif("dn: foo=bar\nfoo: bar\nbaz: do\n\ndn: foo=bar\nfoo: bar\nbaz: dont\n")
541 msg1
= msgs
.next()[1]
542 msg2
= msgs
.next()[1]
543 msgdiff
= l
.msg_diff(msg1
, msg2
)
544 self
.assertEquals("foo=bar", msgdiff
.get("dn").__str
__())
545 self
.assertRaises(KeyError, lambda: msgdiff
["foo"])
546 self
.assertEquals(1, len(msgdiff
))
548 def test_equal_empty(self
):
551 self
.assertEquals(msg1
, msg2
)
553 def test_equal_simplel(self
):
554 db
= ldb
.Ldb(filename())
556 msg1
.dn
= ldb
.Dn(db
, "foo=bar")
558 msg2
.dn
= ldb
.Dn(db
, "foo=bar")
559 self
.assertEquals(msg1
, msg2
)
562 self
.assertEquals(msg1
, msg2
)
564 self
.assertNotEquals(msg1
, msg2
)
567 def test_from_dict(self
):
568 rec
= {"dn": "dc=fromdict",
569 "a1": ["a1-val1", "a1-val1"]}
571 # check different types of input Flags
572 for flags
in [ldb
.FLAG_MOD_ADD
, ldb
.FLAG_MOD_REPLACE
, ldb
.FLAG_MOD_DELETE
]:
573 m
= ldb
.Message
.from_dict(l
, rec
, flags
)
574 self
.assertEquals(rec
["a1"], list(m
["a1"]))
575 self
.assertEquals(flags
, m
["a1"].flags())
577 self
.assertRaises(TypeError, ldb
.Message
.from_dict
, dict(), rec
, ldb
.FLAG_MOD_REPLACE
)
578 self
.assertRaises(TypeError, ldb
.Message
.from_dict
, l
, list(), ldb
.FLAG_MOD_REPLACE
)
579 self
.assertRaises(ValueError, ldb
.Message
.from_dict
, l
, rec
, 0)
580 # Message.from_dict expects dictionary with 'dn'
581 err_rec
= {"a1": ["a1-val1", "a1-val1"]}
582 self
.assertRaises(TypeError, ldb
.Message
.from_dict
, l
, err_rec
, ldb
.FLAG_MOD_REPLACE
)
586 class MessageElementTests(unittest
.TestCase
):
588 def test_cmp_element(self
):
589 x
= ldb
.MessageElement(["foo"])
590 y
= ldb
.MessageElement(["foo"])
591 z
= ldb
.MessageElement(["bzr"])
592 self
.assertEquals(x
, y
)
593 self
.assertNotEquals(x
, z
)
595 def test_create_iterable(self
):
596 x
= ldb
.MessageElement(["foo"])
597 self
.assertEquals(["foo"], list(x
))
600 x
= ldb
.MessageElement(["foo"])
601 self
.assertEquals("MessageElement(['foo'])", repr(x
))
602 x
= ldb
.MessageElement(["foo", "bla"])
603 self
.assertEquals(2, len(x
))
604 self
.assertEquals("MessageElement(['foo','bla'])", repr(x
))
606 def test_get_item(self
):
607 x
= ldb
.MessageElement(["foo", "bar"])
608 self
.assertEquals("foo", x
[0])
609 self
.assertEquals("bar", x
[1])
610 self
.assertEquals("bar", x
[-1])
611 self
.assertRaises(IndexError, lambda: x
[45])
614 x
= ldb
.MessageElement(["foo", "bar"])
615 self
.assertEquals(2, len(x
))
618 x
= ldb
.MessageElement(["foo", "bar"])
619 y
= ldb
.MessageElement(["foo", "bar"])
620 self
.assertEquals(y
, x
)
621 x
= ldb
.MessageElement(["foo"])
622 self
.assertNotEquals(y
, x
)
623 y
= ldb
.MessageElement(["foo"])
624 self
.assertEquals(y
, x
)
626 def test_extended(self
):
627 el
= ldb
.MessageElement(["456"], ldb
.FLAG_MOD_ADD
, "bla")
628 self
.assertEquals("MessageElement(['456'])", repr(el
))
631 class ModuleTests(unittest
.TestCase
):
633 def test_register_module(self
):
636 ldb
.register_module(ExampleModule
)
638 def test_use_module(self
):
643 def __init__(self
, ldb
, next
):
647 def search(self
, *args
, **kwargs
):
648 return self
.next
.search(*args
, **kwargs
)
650 def request(self
, *args
, **kwargs
):
654 ldb
.register_module(ExampleModule
)
655 if os
.path
.exists(name
):
658 l
.add({"dn": "@MODULES", "@LIST": "bla"})
659 self
.assertEquals([], ops
)
661 self
.assertEquals(["init"], ops
)
663 class LdbResultTests(unittest
.TestCase
):
668 if os
.path
.exists(name
):
670 self
.l
= ldb
.Ldb(name
)
671 self
.l
.add({"dn": "DC=SAMBA,DC=ORG", "name": "samba.org"})
672 self
.l
.add({"dn": "OU=ADMIN,DC=SAMBA,DC=ORG", "name": "Admins"})
673 self
.l
.add({"dn": "OU=USERS,DC=SAMBA,DC=ORG", "name": "Users"})
674 self
.l
.add({"dn": "OU=OU1,DC=SAMBA,DC=ORG", "name": "OU #1"})
675 self
.l
.add({"dn": "OU=OU2,DC=SAMBA,DC=ORG", "name": "OU #2"})
676 self
.l
.add({"dn": "OU=OU3,DC=SAMBA,DC=ORG", "name": "OU #3"})
677 self
.l
.add({"dn": "OU=OU4,DC=SAMBA,DC=ORG", "name": "OU #4"})
678 self
.l
.add({"dn": "OU=OU5,DC=SAMBA,DC=ORG", "name": "OU #5"})
679 self
.l
.add({"dn": "OU=OU6,DC=SAMBA,DC=ORG", "name": "OU #6"})
680 self
.l
.add({"dn": "OU=OU7,DC=SAMBA,DC=ORG", "name": "OU #7"})
681 self
.l
.add({"dn": "OU=OU8,DC=SAMBA,DC=ORG", "name": "OU #8"})
682 self
.l
.add({"dn": "OU=OU9,DC=SAMBA,DC=ORG", "name": "OU #9"})
683 self
.l
.add({"dn": "OU=OU10,DC=SAMBA,DC=ORG", "name": "OU #10"})
686 if os
.path
.exists(self
.name
):
689 def test_return_type(self
):
690 res
= self
.l
.search()
691 self
.assertEquals(str(res
), "<ldb result>")
693 def test_get_msgs(self
):
694 res
= self
.l
.search()
697 def test_get_controls(self
):
698 res
= self
.l
.search()
701 def test_get_referals(self
):
702 res
= self
.l
.search()
705 def test_iter_msgs(self
):
707 for l
in self
.l
.search().msgs
:
708 if str(l
.dn
) == "OU=OU10,DC=SAMBA,DC=ORG":
710 self
.assertTrue(found
)
712 def test_iter_msgs_count(self
):
713 self
.assertTrue(self
.l
.search().count
> 0)
714 # 13 objects has been added to the DC=SAMBA, DC=ORG
715 self
.assertEqual(self
.l
.search(base
="DC=SAMBA,DC=ORG").count
, 13)
717 def test_iter_controls(self
):
718 res
= self
.l
.search().controls
721 def test_create_control(self
):
722 self
.assertRaises(ValueError, ldb
.Control
, self
.l
, "tatayoyo:0")
723 c
= ldb
.Control(self
.l
, "relax:1")
724 self
.assertEquals(c
.critical
, True)
725 self
.assertEquals(c
.oid
, "1.3.6.1.4.1.4203.666.5.12")
727 def test_iter_refs(self
):
728 res
= self
.l
.search().referals
731 def test_iter_as_sequence_msgs(self
):
733 res
= self
.l
.search().msgs
735 for i
in range(0, len(res
)):
737 if str(l
.dn
) == "OU=OU10,DC=SAMBA,DC=ORG":
739 self
.assertTrue(found
)
741 def test_iter_as_sequence(self
):
743 res
= self
.l
.search()
745 for i
in range(0, len(res
)):
747 if str(l
.dn
) == "OU=OU10,DC=SAMBA,DC=ORG":
749 self
.assertTrue(found
)
751 class VersionTests(unittest
.TestCase
):
753 def test_version(self
):
754 self
.assertTrue(isinstance(ldb
.__version
__, str))
757 if __name__
== '__main__':
759 unittest
.TestProgram()