Ignore:
Timestamp:
Nov 27, 2012, 4:43:17 PM (13 years ago)
Author:
Silvan Scherrer
Message:

Samba Server: updated trunk to 3.6.0

Location:
trunk/server
Files:
2 deleted
8 edited
1 copied

Legend:

Unmodified
Added
Removed

  • trunk/server

  • trunk/server/source4/lib/ldb/tests/photo.ldif

    r414 r745  
    22changetype: modify
    33add: jpegPhoto
    4 jpegPhoto:< file://tests/tmp/samba4.png
     4jpegPhoto:< file://tests/samba4.png
    55

  • trunk/server/source4/lib/ldb/tests/python/api.py

    r414 r745  
    1 #!/usr/bin/python
     1#!/usr/bin/env python
    22# Simple tests for the ldb python bindings.
    33# Copyright (C) 2007 Jelmer Vernooij <jelmer@samba.org>
    44
    5 import os, sys
     5import os
    66import unittest
    77
    8 # Required for the standalone LDB build
    9 sys.path.append("build/lib.linux-i686-2.4")
    10 
    118import ldb
    129
     10
    1311def 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)
    1518
    1619class NoContextTests(unittest.TestCase):
    … …  
    5861
    5962    def test_modules_tdb(self):
    60         x = ldb.Ldb("bar.ldb")
     63        x = ldb.Ldb(filename())
    6164        self.assertEquals("[<ldb module 'tdb'>]", repr(x.modules()))
    6265
    … …  
    7881
    7982    def test_search_attr_string(self):
    80         l = ldb.Ldb("foo.tdb")
     83        l = ldb.Ldb(filename())
    8184        self.assertRaises(TypeError, l.search, attrs="dc")
    8285
    … …  
    9699        self.assertRaises(ldb.LdbError, lambda: l.delete(ldb.Dn(l, "dc=foo2")))
    97100
     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
    98110    def test_contains(self):
    99         l = ldb.Ldb(filename())
     111        name = filename()
     112        l = ldb.Ldb(name)
    100113        self.assertFalse(ldb.Dn(l, "dc=foo3") in l)
    101         l = ldb.Ldb(filename())
     114        l = ldb.Ldb(name)
    102115        m = ldb.Message()
    103116        m.dn = ldb.Dn(l, "dc=foo3")
    … …  
    209222            rm = l.search(m.dn)[0]
    210223            self.assertEquals(1, len(rm))
    211             rm = l.search(m.dn, attrs=["bla"])[0]
     224            rm = l.search(m.dn, attrs=["bla"])
    212225            self.assertEquals(0, len(rm))
    213226        finally:
    … …  
    267280            self.assertEquals(2, len(rm))
    268281            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
    271284            m["bla"] = ldb.MessageElement(["456"], ldb.FLAG_MOD_ADD, "bla")
    272285            m["bla"].set_flags(ldb.FLAG_MOD_DELETE)
    … …  
    275288            self.assertEquals(1, len(rm))
    276289            self.assertEquals(["1234"], list(rm["bla"]))
    277            
    278290        finally:
    279291            l.delete(ldb.Dn(l, "dc=add"))
    … …  
    316328        self.assertEquals("foo\0bar", res[0]["displayname"][0])
    317329
     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
    318334
    319335class DnTests(unittest.TestCase):
    … …  
    332348        y = ldb.Dn(self.ldb, "dc=foo11,bar=bloe")
    333349        self.assertEquals(x, y)
     350        y = ldb.Dn(self.ldb, "dc=foo11,bar=blie")
     351        self.assertNotEquals(x, y)
    334352
    335353    def test_str(self):
    … …  
    356374        x = ldb.Dn(self.ldb, "@BLA")
    357375        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)
    365376
    366377    def test_is_valid(self):
    … …  
    368379        self.assertTrue(x.is_valid())
    369380        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())
    373382
    374383    def test_is_special(self):
    … …  
    413422        ldif = self.ldb.write_ldif(msg[1], ldb.CHANGETYPE_NONE)
    414423        self.assertEquals("dn: foo=bar\n\n", ldif)
    415        
     424
    416425    def test_parse_ldif_more(self):
    417426        msgs = self.ldb.parse_ldif("dn: foo=bar\n\n\ndn: bar=bar")
    … …  
    441450    def test_iter_items(self):
    442451        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")
    444453        self.assertEquals(1, len(self.msg.items()))
    445454
    446455    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")
    448457        self.msg["dc"] = "foo"
    449458        self.assertEquals("Message({'dn': Dn('dc=foo29'), 'dc': MessageElement(['foo'])})", repr(self.msg))
    … …  
    457466    def test_del(self):
    458467        del self.msg["foo"]
     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())
    459479
    460480    def test_add_value(self):
    … …  
    476496
    477497    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")
    479499        self.msg["foo"] = ["bla"]
    480500        self.msg["bar"] = ["bla"]
    … …  
    486506
    487507    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")
    489509        self.assertEquals("@BASEINFO", self.msg.get("dn").__str__())
    490510
    491511    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")
    493513        self.assertRaises(TypeError, self.msg.get, 42)
    494514
    … …  
    510530        self.assertEquals(1, len(msgdiff))
    511531
     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
    512568
    513569
    … …  
    552608        self.assertEquals(y, x)
    553609
     610    def test_extended(self):
     611        el = ldb.MessageElement(["456"], ldb.FLAG_MOD_ADD, "bla")
     612        self.assertEquals("MessageElement(['456'])", repr(el))
     613
    554614
    555615class ModuleTests(unittest.TestCase):
    … …  
    572632                return self.next.search(*args, **kwargs)
    573633
     634        def request(self, *args, **kwargs):
     635            pass
     636
     637        name = filename()
    574638        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)
    578642        l.add({"dn": "@MODULES", "@LIST": "bla"})
    579643        self.assertEquals([], ops)
    580         l = ldb.Ldb("usemodule.ldb")
     644        l = ldb.Ldb(name)
    581645        self.assertEquals(["init"], ops)
     646
     647class 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
     735class VersionTests(unittest.TestCase):
     736
     737    def test_version(self):
     738        self.assertTrue(isinstance(ldb.__version__, str))
    582739
    583740

  • trunk/server/source4/lib/ldb/tests/sample_module.c

    r414 r745  
    2222*/
    2323
     24#include "replace.h"
     25#include "system/filesys.h"
     26#include "system/time.h"
    2427#include "ldb_module.h"
    2528
    26 int sample_add(struct ldb_module *mod, struct ldb_request *req)
     29static int sample_add(struct ldb_module *mod, struct ldb_request *req)
    2730{
     31        struct ldb_control *control;
     32
    2833        ldb_msg_add_fmt(req->op.add.message, "touchedBy", "sample");
    2934
    30         return ldb_next_request(mod, req);
     35        /* check if there's a relax control */
     36        control = ldb_request_get_control(req, LDB_CONTROL_RELAX_OID);
     37        if (control == NULL) {
     38                /* not found go on */
     39                return ldb_next_request(mod, req);
     40        } else {
     41                return LDB_ERR_UNWILLING_TO_PERFORM;
     42        }
    3143}
    3244
    33 const struct ldb_module_ops ldb_sample_module_ops = {
     45static int sample_modify(struct ldb_module *mod, struct ldb_request *req)
     46{
     47        struct ldb_control *control;
     48
     49        /* check if there's a relax control */
     50        control = ldb_request_get_control(req, LDB_CONTROL_RELAX_OID);
     51        if (control == NULL) {
     52                /* not found go on */
     53                return ldb_next_request(mod, req);
     54        } else {
     55                return LDB_ERR_UNWILLING_TO_PERFORM;
     56        }
     57}
     58
     59
     60static struct ldb_module_ops ldb_sample_module_ops = {
    3461        .name              = "sample",
    3562        .add               = sample_add,
     63        .del               = sample_modify,
     64        .modify            = sample_modify,
    3665};
     66
     67int ldb_sample_init(const char *version)
     68{
     69        LDB_MODULE_CHECK_VERSION(version);
     70        return ldb_register_module(&ldb_sample_module_ops);
     71}

  • trunk/server/source4/lib/ldb/tests/test-generic.sh

    r414 r745  
    4545}
    4646
    47 echo "testing indexed search"
     47echo "Testing indexed search"
    4848$VALGRIND ldbsearch$EXEEXT '(uid=uham)'  || exit 1
    4949$VALGRIND ldbsearch$EXEEXT '(&(objectclass=person)(objectclass=person)(objectclass=top))' || exit 1
    … …  
    8282
    8383echo "Testing binary file attribute value"
    84 mkdir -p tests/tmp
    85 cp $LDBDIR/tests/samba4.png tests/tmp/samba4.png
    8684$VALGRIND ldbmodify$EXEEXT $LDBDIR/tests/photo.ldif || exit 1
    8785count=`$VALGRIND ldbsearch$EXEEXT '(cn=Hampster Ursula)' jpegPhoto | grep '^dn' | wc -l`
    … …  
    9088    exit 1
    9189fi
    92 rm -f tests/tmp/samba4.png
    9390
    9491echo "*TODO* Testing UTF8 upper lower case searches !!"

  • trunk/server/source4/lib/ldb/tests/test-schema.sh

    r414 r745  
    2020$VALGRIND bin/ldbmodify $LDBDIR/tests/schema-tests/schema-mod-test-3.ldif || exit 1
    2121$VALGRIND bin/ldbmodify $LDBDIR/tests/schema-tests/schema-mod-test-4.ldif
    22 if [ "$?" == "0" ]; then
     22if [ "$?" = "0" ]; then
    2323        echo "test failed!"
    2424        exit 1
    2525fi
    2626$VALGRIND bin/ldbmodify $LDBDIR/tests/schema-tests/schema-mod-test-5.ldif
    27 if [ "$?" == "0" ]; then
     27if [ "$?" = "0" ]; then
    2828        echo "test failed!"
    2929        exit 1

  • trunk/server/source4/lib/ldb/tests/test-tdb.sh

    r414 r745  
    3030
    3131. $LDBDIR/tests/test-tdb-features.sh
     32
     33. $LDBDIR/tests/test-controls.sh

  • trunk/server/source4/lib/ldb/tests/test.ldif

    r414 r745  
    410410facsimiletelephonenumber: +1 313 555 9700
    411411telephonenumber: +1 313 555 5331
     412
     413dn: cn=Fred Bassett,ou=Alumni Association,ou=People,o=University of Michigan,c=TEST
     414objectclass: OpenLDAPperson
     415cn: Fred Bassett
     416sn: Bassett
     417uid: Bassett, Fred
Note: See TracChangeset for help on using the changeset viewer.