← Back to branch summary

~ubuntu-branches/ubuntu/precise/samba/precise

« back to all changes in this revision

Viewing changes to source4/lib/ldb/tests/python/api.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2011-12-21 13:18:04 UTC
  • mfrom: (0.39.21 sid)
  • Revision ID: package-import@ubuntu.com-20111221131804-xtlr39wx6njehxxr
Tags: 2:3.6.1-3ubuntu1
* Merge from Debian testing.  Remaining changes:
  + debian/patches/VERSION.patch:
    - set SAMBA_VERSION_SUFFIX to Ubuntu.
  + debian/patches/error-trans.fix-276472:
    - Add the translation of Unix Error code -ENOTSUP to NT Error Code
    - NT_STATUS_NOT_SUPPORTED to prevent the Permission denied error.
  + debian/smb.conf:
    - add "(Samba, Ubuntu)" to server string.
    - comment out the default [homes] share, and add a comment about
      "valid users = %S" to show users how to restrict access to
      \\server\username to only username.
    - Set 'usershare allow guests', so that usershare admins are 
      allowed to create public shares in addition to authenticated
      ones.
    - add map to guest = Bad user, maps bad username to guest access.
  + debian/samba-common.config:
    - Do not change priority to high if dhclient3 is installed.
    - Use priority medium instead of high for the workgroup question.
  + debian/control:
    - Don't build against or suggest ctdb.
    - Add dependency on samba-common-bin to samba.
  + Add ufw integration:
    - Created debian/samba.ufw.profile
    - debian/rules, debian/samba.dirs, debian/samba.files: install
      profile
    - debian/control: have samba suggest ufw
  + Add apport hook:
    - Created debian/source_samba.py.
    - debian/rules, debian/samba.dirs, debian/samba-common-bin.files: install
  + Switch to upstart:
    - Add debian/samba.{nmbd,smbd}.upstart.
  + debian/samba.logrotate, debian/samba-common.dhcp, debian/samba.if-up:
    - Make them upstart compatible
  + debian/samba.postinst: 
    - Avoid scary pdbedit warnings on first import.
  + debian/samba-common.postinst: Add more informative error message for
    the case where smb.conf was manually deleted
  + debian/patches/fix-debuglevel-name-conflict.patch: don't use 'debug_level'
    as a global variable name in an NSS module 
  + Dropped:
    - debian/patches/error-trans.fix-276472
    - debian/patches/fix-debuglevel-name-conflict.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
source4/lib/ldb/tests/python/api.py
1
 
#!/usr/bin/python
 
1
#!/usr/bin/env python
2
2
# Simple tests for the ldb python bindings.
3
3
# Copyright (C) 2007 Jelmer Vernooij <jelmer@samba.org>
4
4
 
5
 
import os, sys
 
5
import os
6
6
import unittest
7
7
 
8
 
# Required for the standalone LDB build
9
 
sys.path.append("build/lib.linux-i686-2.4")
10
 
 
11
8
import ldb
12
9
 
 
10
 
13
11
def filename():
14
 
    return os.tempnam()
 
12
    import tempfile
 
13
    try:
 
14
        dir_prefix = os.path.join(os.environ["SELFTEST_PREFIX"], "tmp")
 
15
    except KeyError:
 
16
        dir_prefix = None
 
17
    return tempfile.mktemp(dir=dir_prefix)
15
18
 
16
19
class NoContextTests(unittest.TestCase):
17
20
 
57
60
        self.assertEquals([], x.modules())
58
61
 
59
62
    def test_modules_tdb(self):
60
 
        x = ldb.Ldb("bar.ldb")
 
63
        x = ldb.Ldb(filename())
61
64
        self.assertEquals("[<ldb module 'tdb'>]", repr(x.modules()))
62
65
 
63
66
    def test_search(self):
77
80
        self.assertEquals(len(l.search("", ldb.SCOPE_SUBTREE, "(dc=*)", ["dc"])), 0)
78
81
 
79
82
    def test_search_attr_string(self):
80
 
        l = ldb.Ldb("foo.tdb")
 
83
        l = ldb.Ldb(filename())
81
84
        self.assertRaises(TypeError, l.search, attrs="dc")
82
85
 
83
86
    def test_opaque(self):
95
98
        l = ldb.Ldb(filename())
96
99
        self.assertRaises(ldb.LdbError, lambda: l.delete(ldb.Dn(l, "dc=foo2")))
97
100
 
 
101
    def test_delete_w_unhandled_ctrl(self):
 
102
        l = ldb.Ldb(filename())
 
103
        m = ldb.Message()
 
104
        m.dn = ldb.Dn(l, "dc=foo1")
 
105
        m["b"] = ["a"]
 
106
        l.add(m)
 
107
        self.assertRaises(ldb.LdbError, lambda: l.delete(m.dn, ["search_options:1:2"]))
 
108
        l.delete(m.dn)
 
109
 
98
110
    def test_contains(self):
99
 
        l = ldb.Ldb(filename())
 
111
        name = filename()
 
112
        l = ldb.Ldb(name)
100
113
        self.assertFalse(ldb.Dn(l, "dc=foo3") in l)
101
 
        l = ldb.Ldb(filename())
 
114
        l = ldb.Ldb(name)
102
115
        m = ldb.Message()
103
116
        m.dn = ldb.Dn(l, "dc=foo3")
104
117
        m["b"] = ["a"]
208
221
            l.modify(m)
209
222
            rm = l.search(m.dn)[0]
210
223
            self.assertEquals(1, len(rm))
211
 
            rm = l.search(m.dn, attrs=["bla"])[0]
 
224
            rm = l.search(m.dn, attrs=["bla"])
212
225
            self.assertEquals(0, len(rm))
213
226
        finally:
214
227
            l.delete(ldb.Dn(l, "dc=modifydelete"))
266
279
            rm = l.search(m.dn)[0]
267
280
            self.assertEquals(2, len(rm))
268
281
            self.assertEquals(["1234", "456"], list(rm["bla"]))
269
 
            
270
 
            #Now create another modify, but switch the flags before we do it
 
282
 
 
283
            # Now create another modify, but switch the flags before we do it
271
284
            m["bla"] = ldb.MessageElement(["456"], ldb.FLAG_MOD_ADD, "bla")
272
285
            m["bla"].set_flags(ldb.FLAG_MOD_DELETE)
273
286
            l.modify(m)
274
287
            rm = l.search(m.dn, attrs=["bla"])[0]
275
288
            self.assertEquals(1, len(rm))
276
289
            self.assertEquals(["1234"], list(rm["bla"]))
277
 
            
278
290
        finally:
279
291
            l.delete(ldb.Dn(l, "dc=add"))
280
292
 
315
327
        res = l.search(expression="(dn=dc=somedn)")
316
328
        self.assertEquals("foo\0bar", res[0]["displayname"][0])
317
329
 
 
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"]))
 
333
 
318
334
 
319
335
class DnTests(unittest.TestCase):
320
336
 
331
347
        x = ldb.Dn(self.ldb, "dc=foo11,bar=bloe")
332
348
        y = ldb.Dn(self.ldb, "dc=foo11,bar=bloe")
333
349
        self.assertEquals(x, y)
 
350
        y = ldb.Dn(self.ldb, "dc=foo11,bar=blie")
 
351
        self.assertNotEquals(x, y)
334
352
 
335
353
    def test_str(self):
336
354
        x = ldb.Dn(self.ldb, "dc=foo12,bar=bloe")
356
374
        x = ldb.Dn(self.ldb, "@BLA")
357
375
        self.assertEquals(None, x.parent())
358
376
 
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
377
    def test_is_valid(self):
367
378
        x = ldb.Dn(self.ldb, "dc=foo18,dc=bloe")
368
379
        self.assertTrue(x.is_valid())
369
380
        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())
 
381
        self.assertTrue(x.is_valid())
373
382
 
374
383
    def test_is_special(self):
375
384
        x = ldb.Dn(self.ldb, "dc=foo19,bar=bloe")
412
421
        self.assertTrue(isinstance(msg[1], ldb.Message))
413
422
        ldif = self.ldb.write_ldif(msg[1], ldb.CHANGETYPE_NONE)
414
423
        self.assertEquals("dn: foo=bar\n\n", ldif)
415
 
        
 
424
 
416
425
    def test_parse_ldif_more(self):
417
426
        msgs = self.ldb.parse_ldif("dn: foo=bar\n\n\ndn: bar=bar")
418
427
        msg = msgs.next()
440
449
 
441
450
    def test_iter_items(self):
442
451
        self.assertEquals(0, len(self.msg.items()))
443
 
        self.msg.dn = ldb.Dn(ldb.Ldb("foo.tdb"), "dc=foo28")
 
452
        self.msg.dn = ldb.Dn(ldb.Ldb(filename()), "dc=foo28")
444
453
        self.assertEquals(1, len(self.msg.items()))
445
454
 
446
455
    def test_repr(self):
447
 
        self.msg.dn = ldb.Dn(ldb.Ldb("foo.tdb"), "dc=foo29")
 
456
        self.msg.dn = ldb.Dn(ldb.Ldb(filename()), "dc=foo29")
448
457
        self.msg["dc"] = "foo"
449
458
        self.assertEquals("Message({'dn': Dn('dc=foo29'), 'dc': MessageElement(['foo'])})", repr(self.msg))
450
459
 
457
466
    def test_del(self):
458
467
        del self.msg["foo"]
459
468
 
 
469
    def test_add(self):
 
470
        self.msg.add(ldb.MessageElement(["456"], ldb.FLAG_MOD_ADD, "bla"))
 
471
 
 
472
    def test_elements_empty(self):
 
473
        self.assertEquals([], self.msg.elements())
 
474
 
 
475
    def test_elements(self):
 
476
        el = ldb.MessageElement(["456"], ldb.FLAG_MOD_ADD, "bla")
 
477
        self.msg.add(el)
 
478
        self.assertEquals([el], self.msg.elements())
 
479
 
460
480
    def test_add_value(self):
461
481
        self.assertEquals(0, len(self.msg))
462
482
        self.msg["foo"] = ["foo"]
475
495
        self.assertEquals(["bar"], list(self.msg["foo"]))
476
496
 
477
497
    def test_keys(self):
478
 
        self.msg.dn = ldb.Dn(ldb.Ldb("foo.tdb"), "@BASEINFO")
 
498
        self.msg.dn = ldb.Dn(ldb.Ldb(filename()), "@BASEINFO")
479
499
        self.msg["foo"] = ["bla"]
480
500
        self.msg["bar"] = ["bla"]
481
501
        self.assertEquals(["dn", "foo", "bar"], self.msg.keys())
485
505
        self.assertEquals("@BASEINFO", self.msg.dn.__str__())
486
506
 
487
507
    def test_get_dn(self):
488
 
        self.msg.dn = ldb.Dn(ldb.Ldb("foo.tdb"), "@BASEINFO")
 
508
        self.msg.dn = ldb.Dn(ldb.Ldb(filename()), "@BASEINFO")
489
509
        self.assertEquals("@BASEINFO", self.msg.get("dn").__str__())
490
510
 
491
511
    def test_get_invalid(self):
492
 
        self.msg.dn = ldb.Dn(ldb.Ldb("foo.tdb"), "@BASEINFO")
 
512
        self.msg.dn = ldb.Dn(ldb.Ldb(filename()), "@BASEINFO")
493
513
        self.assertRaises(TypeError, self.msg.get, 42)
494
514
 
495
515
    def test_get_other(self):
509
529
        self.assertRaises(KeyError, lambda: msgdiff["foo"])
510
530
        self.assertEquals(1, len(msgdiff))
511
531
 
 
532
    def test_equal_empty(self):
 
533
        msg1 = ldb.Message()
 
534
        msg2 = ldb.Message()
 
535
        self.assertEquals(msg1, msg2)
 
536
 
 
537
    def test_equal_simplel(self):
 
538
        db = ldb.Ldb(filename())
 
539
        msg1 = ldb.Message()
 
540
        msg1.dn = ldb.Dn(db, "foo=bar")
 
541
        msg2 = ldb.Message()
 
542
        msg2.dn = ldb.Dn(db, "foo=bar")
 
543
        self.assertEquals(msg1, msg2)
 
544
        msg1['foo'] = 'bar'
 
545
        msg2['foo'] = 'bar'
 
546
        self.assertEquals(msg1, msg2)
 
547
        msg2['foo'] = 'blie'
 
548
        self.assertNotEquals(msg1, msg2)
 
549
        msg2['foo'] = 'blie'
 
550
 
 
551
    def test_from_dict(self):
 
552
        rec = {"dn": "dc=fromdict",
 
553
               "a1": ["a1-val1", "a1-val1"]}
 
554
        l = ldb.Ldb()
 
555
        # check different types of input Flags
 
556
        for flags in [ldb.FLAG_MOD_ADD, ldb.FLAG_MOD_REPLACE, ldb.FLAG_MOD_DELETE]:
 
557
            m = ldb.Message.from_dict(l, rec, flags)
 
558
            self.assertEquals(rec["a1"], list(m["a1"]))
 
559
            self.assertEquals(flags, m["a1"].flags())
 
560
        # check input params
 
561
        self.assertRaises(TypeError, ldb.Message.from_dict, dict(), rec, ldb.FLAG_MOD_REPLACE)
 
562
        self.assertRaises(TypeError, ldb.Message.from_dict, l, list(), ldb.FLAG_MOD_REPLACE)
 
563
        self.assertRaises(ValueError, ldb.Message.from_dict, l, rec, 0)
 
564
        # Message.from_dict expects dictionary with 'dn'
 
565
        err_rec = {"a1": ["a1-val1", "a1-val1"]}
 
566
        self.assertRaises(TypeError, ldb.Message.from_dict, l, err_rec, ldb.FLAG_MOD_REPLACE)
 
567
 
512
568
 
513
569
 
514
570
class MessageElementTests(unittest.TestCase):
551
607
        y = ldb.MessageElement(["foo"])
552
608
        self.assertEquals(y, x)
553
609
 
 
610
    def test_extended(self):
 
611
        el = ldb.MessageElement(["456"], ldb.FLAG_MOD_ADD, "bla")
 
612
        self.assertEquals("MessageElement(['456'])", repr(el))
 
613
 
554
614
 
555
615
class ModuleTests(unittest.TestCase):
556
616
 
571
631
            def search(self, *args, **kwargs):
572
632
                return self.next.search(*args, **kwargs)
573
633
 
 
634
        def request(self, *args, **kwargs):
 
635
            pass
 
636
 
 
637
        name = filename()
574
638
        ldb.register_module(ExampleModule)
575
 
        if os.path.exists("usemodule.ldb"):
576
 
            os.unlink("usemodule.ldb")
577
 
        l = ldb.Ldb("usemodule.ldb")
 
639
        if os.path.exists(name):
 
640
            os.unlink(name)
 
641
        l = ldb.Ldb(name)
578
642
        l.add({"dn": "@MODULES", "@LIST": "bla"})
579
643
        self.assertEquals([], ops)
580
 
        l = ldb.Ldb("usemodule.ldb")
 
644
        l = ldb.Ldb(name)
581
645
        self.assertEquals(["init"], ops)
582
646
 
 
647
class LdbResultTests(unittest.TestCase):
 
648
 
 
649
    def setUp(self):
 
650
        name = filename()
 
651
        self.name = name
 
652
        if os.path.exists(name):
 
653
            os.unlink(name)
 
654
        self.l = ldb.Ldb(name)
 
655
        self.l.add({"dn": "DC=SAMBA,DC=ORG", "name": "samba.org"})
 
656
        self.l.add({"dn": "OU=ADMIN,DC=SAMBA,DC=ORG", "name": "Admins"})
 
657
        self.l.add({"dn": "OU=USERS,DC=SAMBA,DC=ORG", "name": "Users"})
 
658
        self.l.add({"dn": "OU=OU1,DC=SAMBA,DC=ORG", "name": "OU #1"})
 
659
        self.l.add({"dn": "OU=OU2,DC=SAMBA,DC=ORG", "name": "OU #2"})
 
660
        self.l.add({"dn": "OU=OU3,DC=SAMBA,DC=ORG", "name": "OU #3"})
 
661
        self.l.add({"dn": "OU=OU4,DC=SAMBA,DC=ORG", "name": "OU #4"})
 
662
        self.l.add({"dn": "OU=OU5,DC=SAMBA,DC=ORG", "name": "OU #5"})
 
663
        self.l.add({"dn": "OU=OU6,DC=SAMBA,DC=ORG", "name": "OU #6"})
 
664
        self.l.add({"dn": "OU=OU7,DC=SAMBA,DC=ORG", "name": "OU #7"})
 
665
        self.l.add({"dn": "OU=OU8,DC=SAMBA,DC=ORG", "name": "OU #8"})
 
666
        self.l.add({"dn": "OU=OU9,DC=SAMBA,DC=ORG", "name": "OU #9"})
 
667
        self.l.add({"dn": "OU=OU10,DC=SAMBA,DC=ORG", "name": "OU #10"})
 
668
 
 
669
    def tearDown(self):
 
670
        if os.path.exists(self.name):
 
671
            os.unlink(self.name)
 
672
 
 
673
    def test_return_type(self):
 
674
        res = self.l.search()
 
675
        self.assertEquals(str(res), "<ldb result>")
 
676
 
 
677
    def test_get_msgs(self):
 
678
        res = self.l.search()
 
679
        list = res.msgs
 
680
 
 
681
    def test_get_controls(self):
 
682
        res = self.l.search()
 
683
        list = res.controls
 
684
 
 
685
    def test_get_referals(self):
 
686
        res = self.l.search()
 
687
        list = res.referals
 
688
 
 
689
    def test_iter_msgs(self):
 
690
        found = False
 
691
        for l in self.l.search().msgs:
 
692
            if str(l.dn) == "OU=OU10,DC=SAMBA,DC=ORG":
 
693
                found = True
 
694
        self.assertTrue(found)
 
695
 
 
696
    def test_iter_msgs_count(self):
 
697
        self.assertTrue(self.l.search().count > 0)
 
698
        # 13 objects has been added to the DC=SAMBA, DC=ORG
 
699
        self.assertEqual(self.l.search(base="DC=SAMBA,DC=ORG").count, 13)
 
700
 
 
701
    def test_iter_controls(self):
 
702
        res = self.l.search().controls
 
703
        it = iter(res)
 
704
 
 
705
    def test_create_control(self):
 
706
        self.assertRaises(ValueError, ldb.Control, self.l, "tatayoyo:0")
 
707
        c = ldb.Control(self.l, "relax:1")
 
708
        self.assertEquals(c.critical, True)
 
709
        self.assertEquals(c.oid, "1.3.6.1.4.1.4203.666.5.12")
 
710
 
 
711
    def test_iter_refs(self):
 
712
        res = self.l.search().referals
 
713
        it = iter(res)
 
714
 
 
715
    def test_iter_as_sequence_msgs(self):
 
716
        found = False
 
717
        res = self.l.search().msgs
 
718
 
 
719
        for i in range(0, len(res)):
 
720
            l = res[i]
 
721
            if str(l.dn) == "OU=OU10,DC=SAMBA,DC=ORG":
 
722
                found = True
 
723
        self.assertTrue(found)
 
724
 
 
725
    def test_iter_as_sequence(self):
 
726
        found = False
 
727
        res = self.l.search()
 
728
 
 
729
        for i in range(0, len(res)):
 
730
            l = res[i]
 
731
            if str(l.dn) == "OU=OU10,DC=SAMBA,DC=ORG":
 
732
                found = True
 
733
        self.assertTrue(found)
 
734
 
 
735
class VersionTests(unittest.TestCase):
 
736
 
 
737
    def test_version(self):
 
738
        self.assertTrue(isinstance(ldb.__version__, str))
 
739
 
583
740
 
584
741
if __name__ == '__main__':
585
742
    import unittest