source4/lib/ldb/tests/python/api.py

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