Exemple #1
0
    def test_recursive_delete(self):
        """Test recursive delete on object
        """
        for i in range(1, 10):
            ou = Unit(LDAP_CONN)
            if i > 1:
                parent = u"ou=unit1,%s" % LDAP_CONN.get_basedn()
                for j in range(2, i):
                    parent = u"ou=unit%d,%s" % (j, parent)
                ou.set_parent(parent)
            ou.name = u"unit%d" % i
            ou.save()

        ou = Unit(LDAP_CONN,  "ou=unit1,%s" % LDAP_CONN.get_basedn())
        ou.delete(recursive=True)
Exemple #2
0
 def test_search(self):
     """Test searching for objects
     """
     self.assertEqual(LDAP_CONN.search(
         QA, search_filter=eq(QA.string, u"Max Blank"))[0].dn,
             'cn=Max Blank,ou=users,dc=company,dc=com'
     )
Exemple #3
0
    def test_filters(self):
        """Test search filters
        """
        users = LDAP_CONN.search(
            PosixUser, search_filter=eq(PosixUser.firstname, u"ĄĆĘ"))
        self.assertNotEqual(users, [])

        users = LDAP_CONN.search(
            PosixUser, search_filter=present(PosixUser.firstname))
        self.assertNotEqual(users, [])

        users = LDAP_CONN.search(
            PosixUser, search_filter=startswith(PosixUser.fullname, u"Max"))
        self.assertNotEqual(users, [])

        users = LDAP_CONN.search(
            PosixUser, search_filter=endswith(PosixUser.fullname, u"Blank"))
        self.assertNotEqual(users, [])

        users = LDAP_CONN.search(
            PosixUser, search_filter=contains(PosixUser.fullname, u"x Bl"))
        self.assertNotEqual(users, [])

        users = LDAP_CONN.search(
            PosixUser, search_filter=opor(
                    contains(PosixUser.fullname, u"ank"),
                    endswith(PosixUser.fullname, u"dict"),
                )
            )
        self.assertNotEqual(users, [])

        users = LDAP_CONN.search(
            PosixUser, search_filter=opnot(eq(PosixUser.fullname, u"NotFound")))
        self.assertNotEqual(users, [])
Exemple #4
0
    def test_rename_with_children(self):
        """Test renaming object with children
        """
        unit = Unit(LDAP_CONN, "ou=rename,dc=company,dc=com")
        unit.name = u"after_rename"
        unit.save()

        old = LDAP_CONN.get(Unit, search_filter=eq(Unit.name, "rename"),
            basedn=unit.dn)
        self.assertEqual(None, old)

        self.assertEqual(unit.dn, u"ou=after_rename,dc=company,dc=com")

        l1_2 = LDAP_CONN.get(Unit, search_filter=eq(Unit.name, 'l1_2'),
            basedn=unit.dn)
        self.assertEqual(l1_2.dn,
            u'ou=l1_2,ou=l1,ou=after_rename,dc=company,dc=com')
        self.assertEqual(l1_2.name, u'l1_2')
Exemple #5
0
    def test_rename_with_children_unicode(self):
        """Test renaming object with children when unicode characters are used
        as part of object dn.
        """
        unit = Unit(LDAP_CONN, "ou=rename_ąźć,dc=company,dc=com")
        unit.name = u"renamed_łóźććżą"
        unit.save()

        old = LDAP_CONN.get(Unit, search_filter=eq(Unit.name, "rename_ąźć"),
            basedn=unit.dn)
        self.assertEqual(None, old)

        self.assertEqual(unit.dn, u"ou=renamed_łóźććżą,dc=company,dc=com")

        l1_1 = LDAP_CONN.get(Unit, search_filter=eq(Unit.name, 'l1_1'),
            basedn=unit.dn)
        self.assertEqual(l1_1.dn,
            u'ou=l1_1,ou=l1,ou=renamed_łóźććżą,dc=company,dc=com')
        self.assertEqual(l1_1.name, u'l1_1')
        self.assertEqual(l1_1.description, u'l1_1 unit')
Exemple #6
0
 def test_move(self):
     """Test moving object
     """
     pg = LDAP_CONN.get(PosixGroup, search_filter=eq('gidNumber', 3345))
     self.assertEqual(pg.dn, 'cn=nazwa2,ou=groups,dc=company,dc=com')
     pg.set_parent('dc=company,dc=com')
     pg.save()
     self.assertEqual(pg.dn, 'cn=nazwa2,dc=company,dc=com')
     pg.set_parent('ou=groups,dc=company,dc=com')
     pg.save()
     self.assertEqual(pg.dn, 'cn=nazwa2,ou=groups,dc=company,dc=com')
Exemple #7
0
 def test_objectlist(self):
     """Test objectlist methods
     """
     users = LDAP_CONN.search(PosixUser)
     user = users.by_dn("cn=Max Blank,ou=users,dc=company,dc=com")
     self.assertEqual(user.dn, "cn=Max Blank,ou=users,dc=company,dc=com")
     user = users.with_attr('shell')[0]
     self.assertEqual(user.dn, "cn=Max Blank,ou=users,dc=company,dc=com")
     user = users.by_dn("cn=InvalidDN,dc=company,dc=com")
     self.assertEqual(user, None)
     s = users.pickle()
     self.assertNotEqual(s, None)
Exemple #8
0
 def test_get_with_multiple_found(self):
     """Test calling directory.get() when multiple objects are found
     """
     LDAP_CONN.get(
         PosixUser, search_filter=eq(PosixUser.object_class, 'top'))
Exemple #9
0
from pumpkin.resource import LDAPResource
from pumpkin.directory import Directory
from pumpkin.models import PosixGroup, PosixUser

from conn import LDAP_CONN


for I in range(10):

    print('Simple search')
    for pg in LDAP_CONN.search(PosixUser):
        print(pg.dn)
        print('\tcn: %s' % pg.fullname)
        print('\tgid: %s' % pg.gid)
        print('\tuid: %s' % pg.uid)
        print('')

"""
print('OC info for: PosixGroup')
(must, may) = LDAP_CONN.get_schema_attrs(PosixGroup)
print('MUST : %s' % must)
print('MAY: %s' % may)
"""