• Home
  • History
  • Annotate
  • Line#
  • Navigate
  • Raw
  • Download
  • only in /asuswrt-rt-n18u-9.0.0.4.380.2695/release/src-rt-6.x.4708/router/samba-3.5.8/source4/lib/ldb/tests/python/
1#!/usr/bin/python
2# Simple tests for the ldb python bindings.
3# Copyright (C) 2007 Jelmer Vernooij <jelmer@samba.org>
4
5import os, sys
6import unittest
7
8# Required for the standalone LDB build
9sys.path.append("build/lib.linux-i686-2.4")
10
11import ldb
12
13def filename():
14    return os.tempnam()
15
16class NoContextTests(unittest.TestCase):
17
18    def test_valid_attr_name(self):
19        self.assertTrue(ldb.valid_attr_name("foo"))
20        self.assertFalse(ldb.valid_attr_name("24foo"))
21
22    def test_timestring(self):
23        self.assertEquals("19700101000000.0Z", ldb.timestring(0))
24        self.assertEquals("20071119191012.0Z", ldb.timestring(1195499412))
25
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"))
29
30
31class SimpleLdb(unittest.TestCase):
32
33    def test_connect(self):
34        ldb.Ldb(filename())
35
36    def test_connect_none(self):
37        ldb.Ldb()
38
39    def test_connect_later(self):
40        x = ldb.Ldb()
41        x.connect(filename())
42
43    def test_repr(self):
44        x = ldb.Ldb()
45        self.assertTrue(repr(x).startswith("<ldb connection"))
46
47    def test_set_create_perms(self):
48        x = ldb.Ldb()
49        x.set_create_perms(0600)
50
51    def test_set_modules_dir(self):
52        x = ldb.Ldb()
53        x.set_modules_dir("/tmp")
54
55    def test_modules_none(self):
56        x = ldb.Ldb()
57        self.assertEquals([], x.modules())
58
59    def test_modules_tdb(self):
60        x = ldb.Ldb("bar.ldb")
61        self.assertEquals("[<ldb module 'tdb'>]", repr(x.modules()))
62
63    def test_search(self):
64        l = ldb.Ldb(filename())
65        self.assertEquals(len(l.search()), 1)
66
67    def test_search_controls(self):
68        l = ldb.Ldb(filename())
69        self.assertEquals(len(l.search(controls=["paged_results:0:5"])), 1)
70
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)
74
75    def test_search_string_dn(self):
76        l = ldb.Ldb(filename())
77        self.assertEquals(len(l.search("", ldb.SCOPE_SUBTREE, "(dc=*)", ["dc"])), 0)
78
79    def test_search_attr_string(self):
80        l = ldb.Ldb("foo.tdb")
81        self.assertRaises(TypeError, l.search, attrs="dc")
82
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"))
88
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)
93
94    def test_delete(self):
95        l = ldb.Ldb(filename())
96        self.assertRaises(ldb.LdbError, lambda: l.delete(ldb.Dn(l, "dc=foo2")))
97
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())
102        m = ldb.Message()
103        m.dn = ldb.Dn(l, "dc=foo3")
104        m["b"] = ["a"]
105        l.add(m)
106        try:
107            self.assertTrue(ldb.Dn(l, "dc=foo3") in l)
108        finally:
109            l.delete(m.dn)
110
111    def test_get_config_basedn(self):
112        l = ldb.Ldb(filename())
113        self.assertEquals(None, l.get_config_basedn())
114
115    def test_get_root_basedn(self):
116        l = ldb.Ldb(filename())
117        self.assertEquals(None, l.get_root_basedn())
118
119    def test_get_schema_basedn(self):
120        l = ldb.Ldb(filename())
121        self.assertEquals(None, l.get_schema_basedn())
122
123    def test_get_default_basedn(self):
124        l = ldb.Ldb(filename())
125        self.assertEquals(None, l.get_default_basedn())
126
127    def test_add(self):
128        l = ldb.Ldb(filename())
129        m = ldb.Message()
130        m.dn = ldb.Dn(l, "dc=foo4")
131        m["bla"] = "bla"
132        self.assertEquals(len(l.search()), 1)
133        l.add(m)
134        try:
135            self.assertEquals(len(l.search()), 2)
136        finally:
137            l.delete(ldb.Dn(l, "dc=foo4"))
138
139    def test_add_w_unhandled_ctrl(self):
140        l = ldb.Ldb(filename())
141        m = ldb.Message()
142        m.dn = ldb.Dn(l, "dc=foo4")
143        m["bla"] = "bla"
144        self.assertEquals(len(l.search()), 1)
145        self.assertRaises(ldb.LdbError, lambda: l.add(m,["search_options:1:2"]))
146
147    def test_add_dict(self):
148        l = ldb.Ldb(filename())
149        m = {"dn": ldb.Dn(l, "dc=foo5"),
150             "bla": "bla"}
151        self.assertEquals(len(l.search()), 1)
152        l.add(m)
153        try:
154            self.assertEquals(len(l.search()), 2)
155        finally:
156            l.delete(ldb.Dn(l, "dc=foo5"))
157
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)
162        l.add(m)
163        try:
164            self.assertEquals(len(l.search()), 2)
165        finally:
166            l.delete(ldb.Dn(l, "dc=foo6"))
167
168    def test_rename(self):
169        l = ldb.Ldb(filename())
170        m = ldb.Message()
171        m.dn = ldb.Dn(l, "dc=foo7")
172        m["bla"] = "bla"
173        self.assertEquals(len(l.search()), 1)
174        l.add(m)
175        try:
176            l.rename(ldb.Dn(l, "dc=foo7"), ldb.Dn(l, "dc=bar"))
177            self.assertEquals(len(l.search()), 2)
178        finally:
179            l.delete(ldb.Dn(l, "dc=bar"))
180
181    def test_rename_string_dns(self):
182        l = ldb.Ldb(filename())
183        m = ldb.Message()
184        m.dn = ldb.Dn(l, "dc=foo8")
185        m["bla"] = "bla"
186        self.assertEquals(len(l.search()), 1)
187        l.add(m)
188        self.assertEquals(len(l.search()), 2)
189        try:
190            l.rename("dc=foo8", "dc=bar")
191            self.assertEquals(len(l.search()), 2)
192        finally:
193            l.delete(ldb.Dn(l, "dc=bar"))
194
195    def test_modify_delete(self):
196        l = ldb.Ldb(filename())
197        m = ldb.Message()
198        m.dn = ldb.Dn(l, "dc=modifydelete")
199        m["bla"] = ["1234"]
200        l.add(m)
201        rm = l.search(m.dn)[0]
202        self.assertEquals(["1234"], list(rm["bla"]))
203        try:
204            m = ldb.Message()
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())
208            l.modify(m)
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))
213        finally:
214            l.delete(ldb.Dn(l, "dc=modifydelete"))
215
216    def test_modify_add(self):
217        l = ldb.Ldb(filename())
218        m = ldb.Message()
219        m.dn = ldb.Dn(l, "dc=add")
220        m["bla"] = ["1234"]
221        l.add(m)
222        try:
223            m = ldb.Message()
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())
227            l.modify(m)
228            rm = l.search(m.dn)[0]
229            self.assertEquals(2, len(rm))
230            self.assertEquals(["1234", "456"], list(rm["bla"]))
231        finally:
232            l.delete(ldb.Dn(l, "dc=add"))
233
234    def test_modify_replace(self):
235        l = ldb.Ldb(filename())
236        m = ldb.Message()
237        m.dn = ldb.Dn(l, "dc=modify2")
238        m["bla"] = ["1234", "456"]
239        l.add(m)
240        try:
241            m = ldb.Message()
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())
245            l.modify(m)
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))
251        finally:
252            l.delete(ldb.Dn(l, "dc=modify2"))
253
254    def test_modify_flags_change(self):
255        l = ldb.Ldb(filename())
256        m = ldb.Message()
257        m.dn = ldb.Dn(l, "dc=add")
258        m["bla"] = ["1234"]
259        l.add(m)
260        try:
261            m = ldb.Message()
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())
265            l.modify(m)
266            rm = l.search(m.dn)[0]
267            self.assertEquals(2, len(rm))
268            self.assertEquals(["1234", "456"], list(rm["bla"]))
269
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)
273            l.modify(m)
274            rm = l.search(m.dn, attrs=["bla"])[0]
275            self.assertEquals(1, len(rm))
276            self.assertEquals(["1234"], list(rm["bla"]))
277
278        finally:
279            l.delete(ldb.Dn(l, "dc=add"))
280
281    def test_transaction_commit(self):
282        l = ldb.Ldb(filename())
283        l.transaction_start()
284        m = ldb.Message(ldb.Dn(l, "dc=foo9"))
285        m["foo"] = ["bar"]
286        l.add(m)
287        l.transaction_commit()
288        l.delete(m.dn)
289
290    def test_transaction_cancel(self):
291        l = ldb.Ldb(filename())
292        l.transaction_start()
293        m = ldb.Message(ldb.Dn(l, "dc=foo10"))
294        m["foo"] = ["bar"]
295        l.add(m)
296        l.transaction_cancel()
297        self.assertEquals(0, len(l.search(ldb.Dn(l, "dc=foo10"))))
298
299    def test_set_debug(self):
300        def my_report_fn(level, text):
301            pass
302        l = ldb.Ldb(filename())
303        l.set_debug(my_report_fn)
304
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())
308        l.add({
309            "dn" : "dc=somedn",
310            "objectclass" : "user",
311            "cN" : "LDAPtestUSER",
312            "givenname" : "ldap",
313            "displayname" : "foo\0bar",
314        })
315        res = l.search(expression="(dn=dc=somedn)")
316        self.assertEquals("foo\0bar", res[0]["displayname"][0])
317
318
319class DnTests(unittest.TestCase):
320
321    def setUp(self):
322        self.ldb = ldb.Ldb(filename())
323
324    def test_set_dn_invalid(self):
325        x = ldb.Message()
326        def assign():
327            x.dn = "astring"
328        self.assertRaises(TypeError, assign)
329
330    def test_eq(self):
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)
334
335    def test_str(self):
336        x = ldb.Dn(self.ldb, "dc=foo12,bar=bloe")
337        self.assertEquals(x.__str__(), "dc=foo12,bar=bloe")
338
339    def test_repr(self):
340        x = ldb.Dn(self.ldb, "dc=foo13,bla=blie")
341        self.assertEquals(x.__repr__(), "Dn('dc=foo13,bla=blie')")
342
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")
346
347    def test_validate(self):
348        x = ldb.Dn(self.ldb, "dc=foo15,bar=bloe")
349        self.assertTrue(x.validate())
350
351    def test_parent(self):
352        x = ldb.Dn(self.ldb, "dc=foo16,bar=bloe")
353        self.assertEquals("bar=bloe", x.parent().__str__())
354
355    def test_parent_nonexistant(self):
356        x = ldb.Dn(self.ldb, "@BLA")
357        self.assertEquals(None, x.parent())
358
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)
365
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())
373
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())
379
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"))
385
386    def test_len(self):
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))
391
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__())
396
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__())
402
403    def test_add(self):
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))
407
408    def test_parse_ldif(self):
409        msgs = self.ldb.parse_ldif("dn: foo=bar\n")
410        msg = msgs.next()
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)
415
416    def test_parse_ldif_more(self):
417        msgs = self.ldb.parse_ldif("dn: foo=bar\n\n\ndn: bar=bar")
418        msg = msgs.next()
419        self.assertEquals("foo=bar", str(msg[1].dn))
420        msg = msgs.next()
421        self.assertEquals("bar=bar", str(msg[1].dn))
422
423    def test_canonical_string(self):
424        x = ldb.Dn(self.ldb, "dc=foo25,bar=bloe")
425        self.assertEquals("/bloe/foo25", x.canonical_str())
426
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())
430
431
432class LdbMsgTests(unittest.TestCase):
433
434    def setUp(self):
435        self.msg = ldb.Message()
436
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))
440
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()))
445
446    def test_repr(self):
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))
450
451    def test_len(self):
452        self.assertEquals(0, len(self.msg))
453
454    def test_notpresent(self):
455        self.assertRaises(KeyError, lambda: self.msg["foo"])
456
457    def test_del(self):
458        del self.msg["foo"]
459
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))
464
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"]))
470
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"]))
476
477    def test_keys(self):
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())
482
483    def test_dn(self):
484        self.msg.dn = ldb.Dn(ldb.Ldb(filename()), "@BASEINFO")
485        self.assertEquals("@BASEINFO", self.msg.dn.__str__())
486
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__())
490
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)
494
495    def test_get_other(self):
496        self.msg["foo"] = ["bar"]
497        self.assertEquals("bar", self.msg.get("foo")[0])
498
499    def test_get_unknown(self):
500        self.assertEquals(None, self.msg.get("lalalala"))
501
502    def test_msg_diff(self):
503        l = ldb.Ldb()
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))
511
512
513
514class MessageElementTests(unittest.TestCase):
515
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)
522
523    def test_create_iterable(self):
524        x = ldb.MessageElement(["foo"])
525        self.assertEquals(["foo"], list(x))
526
527    def test_repr(self):
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))
533
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])
540
541    def test_len(self):
542        x = ldb.MessageElement(["foo", "bar"])
543        self.assertEquals(2, len(x))
544
545    def test_eq(self):
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)
553
554
555class ModuleTests(unittest.TestCase):
556
557    def test_register_module(self):
558        class ExampleModule:
559            name = "example"
560        ldb.register_module(ExampleModule)
561
562    def test_use_module(self):
563        ops = []
564        class ExampleModule:
565            name = "bla"
566
567            def __init__(self, ldb, next):
568                ops.append("init")
569                self.next = next
570
571            def search(self, *args, **kwargs):
572                return self.next.search(*args, **kwargs)
573
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)
582
583
584if __name__ == '__main__':
585    import unittest
586    unittest.TestProgram()
587