d5346c30b09a244fcd1c892caa58298557b49f79
[samba.git] / source4 / lib / ldb / tests / python / api.py
1 #!/usr/bin/python
2 # Simple tests for the ldb python bindings.
3 # Copyright (C) 2007 Jelmer Vernooij <jelmer@samba.org>
4
5 import sys
6 import unittest
7
8 # Required for the standalone LDB build
9 sys.path.append("swig")
10 sys.path.append("build/lib.linux-i686-2.4")
11
12 import ldb
13
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"))
18
19     def test_timestring(self):
20         self.assertEquals("19700101000000.0Z", ldb.timestring(0))
21         self.assertEquals("20071119191012.0Z", ldb.timestring(1195499412))
22
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"))
26
27
28 class SimpleLdb(unittest.TestCase):
29     def test_connect(self):
30         ldb.Ldb("foo.tdb")
31
32     def test_connect_none(self):
33         ldb.Ldb()
34
35     def test_connect_later(self):
36         x = ldb.Ldb()
37         x.connect("foo.tdb")
38
39     def test_set_create_perms(self):
40         x = ldb.Ldb()
41         x.set_create_perms(0600)
42
43     def test_set_modules_dir(self):
44         x = ldb.Ldb()
45         x.set_modules_dir("/tmp")
46
47     def test_search(self):
48         l = ldb.Ldb("foo.tdb")
49         self.assertEquals(len(l.search()), 1)
50
51     def test_search_controls(self):
52         l = ldb.Ldb("foo.tdb")
53         self.assertEquals(len(l.search(controls=["paged_results:1:5"])), 1)
54
55     def test_search_attrs(self):
56         l = ldb.Ldb("foo.tdb")
57         self.assertEquals(len(l.search(ldb.Dn(l, ""), ldb.SCOPE_SUBTREE, "(dc=*)", ["dc"])), 0)
58
59     def test_search_string_dn(self):
60         l = ldb.Ldb("foo.tdb")
61         self.assertEquals(len(l.search("", ldb.SCOPE_SUBTREE, "(dc=*)", ["dc"])), 0)
62
63     def test_opaque(self):
64         l = ldb.Ldb("foo.tdb")
65         l.set_opaque("my_opaque", l)
66         self.assertTrue(l.get_opaque("my_opaque") is not None)
67         self.assertEquals(None, l.get_opaque("unknown"))
68
69     def test_parse_control_strings(self):
70         l = ldb.Ldb("foo.tdb")
71         self.assertRaises(ldb.LdbError, l.parse_control_strings, ["foo", "bar"])
72         self.assertTrue(l.parse_control_strings(["paged_results:1:5"]) is not None)
73
74     def test_search_scope_base(self):
75         l = ldb.Ldb("foo.tdb")
76         self.assertEquals(len(l.search(ldb.Dn(l, "dc=foo"), 
77                           ldb.SCOPE_ONELEVEL)), 0)
78
79     def test_delete(self):
80         l = ldb.Ldb("foo.tdb")
81         self.assertRaises(ldb.LdbError, lambda: l.delete(ldb.Dn(l, "dc=foo")))
82
83     def test_contains(self):
84         l = ldb.Ldb("foo.tdb")
85         self.assertFalse(ldb.Dn(l, "dc=foo") in l)
86         l = ldb.Ldb("foo.tdb")
87         m = ldb.Message()
88         m.dn = ldb.Dn(l, "dc=foo")
89         m["b"] = ["a"]
90         l.add(m)
91         try:
92             self.assertTrue(ldb.Dn(l, "dc=foo") in l)
93         finally:
94             l.delete(m.dn)
95
96     def test_get_config_basedn(self):
97         l = ldb.Ldb("foo.tdb")
98         self.assertEquals(None, l.get_config_basedn())
99
100     def test_get_root_basedn(self):
101         l = ldb.Ldb("foo.tdb")
102         self.assertEquals(None, l.get_root_basedn())
103
104     def test_get_schema_basedn(self):
105         l = ldb.Ldb("foo.tdb")
106         self.assertEquals(None, l.get_schema_basedn())
107
108     def test_get_default_basedn(self):
109         l = ldb.Ldb("foo.tdb")
110         self.assertEquals(None, l.get_default_basedn())
111
112     def test_add(self):
113         l = ldb.Ldb("foo.tdb")
114         m = ldb.Message()
115         m.dn = ldb.Dn(l, "dc=foo")
116         m["bla"] = "bla"
117         self.assertEquals(len(l.search()), 1)
118         l.add(m)
119         try:
120             self.assertEquals(len(l.search()), 2)
121         finally:
122             l.delete(ldb.Dn(l, "dc=foo"))
123
124     def test_add_dict(self):
125         l = ldb.Ldb("foo.tdb")
126         m = {"dn": ldb.Dn(l, "dc=foo"),
127              "bla": "bla"}
128         self.assertEquals(len(l.search()), 1)
129         l.add(m)
130         try:
131             self.assertEquals(len(l.search()), 2)
132         finally:
133             l.delete(ldb.Dn(l, "dc=foo"))
134
135     def test_add_dict_string_dn(self):
136         l = ldb.Ldb("foo.tdb")
137         m = {"dn": "dc=foo", "bla": "bla"}
138         self.assertEquals(len(l.search()), 1)
139         l.add(m)
140         try:
141             self.assertEquals(len(l.search()), 2)
142         finally:
143             l.delete(ldb.Dn(l, "dc=foo"))
144
145     def test_rename(self):
146         l = ldb.Ldb("foo.tdb")
147         m = ldb.Message()
148         m.dn = ldb.Dn(l, "dc=foo")
149         m["bla"] = "bla"
150         self.assertEquals(len(l.search()), 1)
151         l.add(m)
152         try:
153             l.rename(ldb.Dn(l, "dc=foo"), ldb.Dn(l, "dc=bar"))
154             self.assertEquals(len(l.search()), 2)
155         finally:
156             l.delete(ldb.Dn(l, "dc=bar"))
157
158     def test_rename_string_dns(self):
159         l = ldb.Ldb("foo.tdb")
160         m = ldb.Message()
161         m.dn = ldb.Dn(l, "dc=foo")
162         m["bla"] = "bla"
163         self.assertEquals(len(l.search()), 1)
164         l.add(m)
165         try:
166             l.rename("dc=foo", "dc=bar")
167             self.assertEquals(len(l.search()), 2)
168         finally:
169             l.delete(ldb.Dn(l, "dc=bar"))
170
171     def test_modify_delete(self):
172         l = ldb.Ldb("foo.tdb")
173         m = ldb.Message()
174         m.dn = ldb.Dn(l, "dc=modifydelete")
175         m["bla"] = ["1234"]
176         l.add(m)
177         rm = l.search(m.dn)[0]
178         self.assertEquals(["1234"], list(rm["bla"]))
179         try:
180             m = ldb.Message()
181             m.dn = ldb.Dn(l, "dc=modifydelete")
182             m["bla"] = ldb.MessageElement([], ldb.CHANGETYPE_DELETE, "bla")
183             l.modify(m)
184             rm = l.search(m.dn)[0]
185             self.assertEquals(1, len(rm))
186         finally:
187             l.delete(ldb.Dn(l, "dc=modifydelete"))
188
189     def test_modify_add(self):
190         l = ldb.Ldb("foo.tdb")
191         m = ldb.Message()
192         m.dn = ldb.Dn(l, "dc=add")
193         m["bla"] = ["1234"]
194         l.add(m)
195         try:
196             m = ldb.Message()
197             m.dn = ldb.Dn(l, "dc=add")
198             m["bla"] = ldb.MessageElement(["456"], ldb.CHANGETYPE_ADD, "bla")
199             l.modify(m)
200             rm = l.search(m.dn)[0]
201             self.assertEquals(2, len(rm))
202             self.assertEquals(["1234", "456"], list(rm["bla"]))
203         finally:
204             l.delete(ldb.Dn(l, "dc=add"))
205
206     def test_modify_modify(self):
207         l = ldb.Ldb("foo.tdb")
208         m = ldb.Message()
209         m.dn = ldb.Dn(l, "dc=modify2")
210         m["bla"] = ["1234", "456"]
211         l.add(m)
212         try:
213             m = ldb.Message()
214             m.dn = ldb.Dn(l, "dc=modify2")
215             m["bla"] = ldb.MessageElement(["456"], ldb.CHANGETYPE_MODIFY, "bla")
216             l.modify(m)
217             rm = l.search(m.dn)[0]
218             self.assertEquals(2, len(rm))
219             self.assertEquals(["1234"], list(rm["bla"]))
220         finally:
221             l.delete(ldb.Dn(l, "dc=modify2"))
222
223     def test_transaction_commit(self):
224         l = ldb.Ldb("foo.tdb")
225         l.transaction_start()
226         m = ldb.Message(ldb.Dn(l, "dc=foo"))
227         m["foo"] = ["bar"]
228         l.add(m)
229         l.transaction_commit()
230         l.delete(m.dn)
231
232     def test_transaction_cancel(self):
233         l = ldb.Ldb("foo.tdb")
234         l.transaction_start()
235         m = ldb.Message(ldb.Dn(l, "dc=foo"))
236         m["foo"] = ["bar"]
237         l.add(m)
238         l.transaction_cancel()
239         self.assertEquals(0, len(l.search(ldb.Dn(l, "dc=foo"))))
240
241     def test_set_debug(self):
242         def my_report_fn(level, text):
243             pass
244         l = ldb.Ldb("foo.tdb")
245         l.set_debug(my_report_fn)
246
247
248 class DnTests(unittest.TestCase):
249     def setUp(self):
250         self.ldb = ldb.Ldb("foo.tdb")
251
252     def test_eq_str(self):
253         x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
254         self.assertEquals("dc=foo,bar=bloe", x)
255
256     def test_str(self):
257         x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
258         self.assertEquals(x.__str__(), "dc=foo,bar=bloe")
259
260     def test_get_casefold(self):
261         x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
262         self.assertEquals(x.get_casefold(), "DC=FOO,BAR=bloe")
263
264     def test_validate(self):
265         x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
266         self.assertTrue(x.validate())
267
268     def test_parent(self):
269         x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
270         self.assertEquals("bar=bloe", x.parent().__str__())
271
272     def test_compare(self):
273         x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
274         y = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
275         self.assertEquals(x, y)
276         z = ldb.Dn(self.ldb, "dc=foo,bar=blie")
277         self.assertNotEquals(z, y)
278
279     def test_is_valid(self):
280         x = ldb.Dn(self.ldb, "dc=foo,dc=bloe")
281         self.assertTrue(x.is_valid())
282         x = ldb.Dn(self.ldb, "")
283         # is_valid()'s return values appears to be a side effect of 
284         # some other ldb functions. yuck.
285         # self.assertFalse(x.is_valid())
286
287     def test_is_special(self):
288         x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
289         self.assertFalse(x.is_special())
290         x = ldb.Dn(self.ldb, "@FOOBAR")
291         self.assertTrue(x.is_special())
292
293     def test_check_special(self):
294         x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
295         self.assertFalse(x.check_special("FOOBAR"))
296         x = ldb.Dn(self.ldb, "@FOOBAR")
297         self.assertTrue(x.check_special("@FOOBAR"))
298
299     def test_len(self):
300         x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
301         self.assertEquals(2, len(x))
302         x = ldb.Dn(self.ldb, "dc=foo")
303         self.assertEquals(1, len(x))
304
305     def test_add_child(self):
306         x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
307         self.assertTrue(x.add_child(ldb.Dn(self.ldb, "bla=bloe")))
308         self.assertEquals("bla=bloe,dc=foo,bar=bloe", x.__str__())
309
310     def test_add_base(self):
311         x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
312         self.assertTrue(x.add_base(ldb.Dn(self.ldb, "bla=bloe")))
313         self.assertEquals("dc=foo,bar=bloe,bla=bloe", x.__str__())
314
315     def test_add(self):
316         x = ldb.Dn(self.ldb, "dc=foo")
317         y = ldb.Dn(self.ldb, "bar=bla")
318         self.assertEquals("dc=foo,bar=bla", str(y + x))
319
320     def test_parse_ldif(self):
321         msgs = self.ldb.parse_ldif("dn: foo=bar\n")
322         msg = msgs.next()
323         self.assertEquals("foo=bar", str(msg[1].dn))
324         self.assertTrue(isinstance(msg[1], ldb.Message))
325
326     def test_parse_ldif_more(self):
327         msgs = self.ldb.parse_ldif("dn: foo=bar\n\n\ndn: bar=bar")
328         msg = msgs.next()
329         self.assertEquals("foo=bar", str(msg[1].dn))
330         msg = msgs.next()
331         self.assertEquals("bar=bar", str(msg[1].dn))
332
333     def test_canonical_string(self):
334         x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
335         self.assertEquals("/bloe/foo", x.canonical_str())
336
337     def test_canonical_ex_string(self):
338         x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
339         self.assertEquals("/bloe\nfoo", x.canonical_ex_str())
340
341
342 class LdbMsgTests(unittest.TestCase):
343     def setUp(self):
344         self.msg = ldb.Message()
345
346     def test_init_dn(self):
347         self.msg = ldb.Message(ldb.Dn(ldb.Ldb(), "dc=foo"))
348         self.assertEquals("dc=foo", str(self.msg.dn))
349
350     def test_len(self):
351         self.assertEquals(0, len(self.msg))
352
353     def test_notpresent(self):
354         self.assertRaises(KeyError, lambda: self.msg["foo"])
355
356     def test_del(self):
357         del self.msg["foo"]
358
359     def test_add_value(self):
360         self.assertEquals(0, len(self.msg))
361         self.msg["foo"] = ["foo"]
362         self.assertEquals(1, len(self.msg))
363
364     def test_add_value_multiple(self):
365         self.assertEquals(0, len(self.msg))
366         self.msg["foo"] = ["foo", "bla"]
367         self.assertEquals(1, len(self.msg))
368         self.assertEquals(["foo", "bla"], list(self.msg["foo"]))
369
370     def test_set_value(self):
371         self.msg["foo"] = ["fool"]
372         self.assertEquals(["fool"], list(self.msg["foo"]))
373         self.msg["foo"] = ["bar"]
374         self.assertEquals(["bar"], list(self.msg["foo"]))
375
376     def test_keys(self):
377         self.msg["foo"] = ["bla"]
378         self.msg["bar"] = ["bla"]
379         self.assertEquals(["foo", "bar"], self.msg.keys())
380
381     def test_dn(self):
382         self.msg.dn = ldb.Dn(ldb.Ldb("foo.tdb"), "@BASEINFO")
383         self.assertEquals("@BASEINFO", self.msg.dn.__str__())
384
385
386 class MessageElementTests(unittest.TestCase):
387     def test_cmp_element(self):
388         x = ldb.MessageElement(["foo"])
389         y = ldb.MessageElement(["foo"])
390         z = ldb.MessageElement(["bzr"])
391         self.assertEquals(x, y)
392         self.assertNotEquals(x, z)
393
394     def test_create_iterable(self):
395         x = ldb.MessageElement(["foo"])
396         self.assertEquals(["foo"], list(x))
397
398     def test_get_item(self):
399         x = ldb.MessageElement(["foo", "bar"])
400         self.assertEquals("foo", x[0])
401         self.assertEquals("bar", x[1])
402         self.assertRaises(KeyError, lambda: x[-1])
403
404     def test_len(self):
405         x = ldb.MessageElement(["foo", "bar"])
406         self.assertEquals(2, len(x))
407
408     def test_eq(self):
409         x = ldb.MessageElement(["foo", "bar"])
410         self.assertEquals(["foo", "bar"], x)
411         x = ldb.MessageElement(["foo"])
412         self.assertEquals("foo", x)
413
414 class ExampleModule:
415     name = "example"
416
417 class ModuleTests(unittest.TestCase):
418     def test_register_module(self):
419         ldb.register_module(ExampleModule())
420