def test_default_with_delay(self):
server = LdapServer(java_delay=1)
server.start()
dn = server.config['bind_dn']
pw = server.config['password']
srv = ldap3.Server('localhost', port=server.config['port'])
conn = ldap3.Connection(srv, user=dn, password=pw, auto_bind=True)
base_dn = server.config['base']['dn']
search_filter = '(objectclass=domain)'
attrs = ['dc']
conn.search(base_dn, search_filter, attributes=attrs)
self.assertEqual(conn.response, [{
'dn': 'dc=example,dc=com',
'raw_attributes': {'dc': [b'example']},
'attributes': {'dc': ['example']},
'type': 'searchResEntry'
}])
conn.unbind()
server.stop()
def setUp(self):
super().setUp()
self._ldap_test_server = LdapServer(self.ldap_server_data)
self._ldap_test_server.start()
ldap3_server = ldap3.Server('localhost',
port=self._ldap_test_server.config['port'])
self._ldap_connection = ldap3.Connection(
ldap3_server,
user=self._ldap_test_server.config['bind_dn'],
password=self._ldap_test_server.config['password'],
auto_bind=True)
def take_action(self, parsed_args):
# TODO - B.S. - 20160210: paramètre argv pour preciser les fixtures
server = LdapServer(ldap_test_server_fixtures)
print("Starting LDAP server on localhost (port %d)" % ldap_test_server_fixtures.get('port'))
print("Press CTRL+C to stop it")
server.start()
try:
while True:
sleep(1)
except KeyboardInterrupt:
pass
def take_action(self, parsed_args):
# TODO - B.S. - 20160210: paramètre argv pour preciser les fixtures
server = LdapServer(ldap_test_server_fixtures)
print("Starting LDAP server on localhost (port %d)" %
ldap_test_server_fixtures.get('port'))
print("Press CTRL+C to stop it")
server.start()
try:
while True:
sleep(1)
except KeyboardInterrupt:
pass
def __init__(self):
self.server_port = get_free_port()
self.ldap_server = LdapServer({
'port': self.server_port,
'bind_dn': self.ldap_bind_dn,
'password': self.ldap_bind_password,
'base': {
'objectclass': ['domain'],
'dn': self.ldap_base_dn,
'attributes': {
'dc': self.ldap_base_dc
}
},
'entries': self.ldap_entries,
})
def test_config(self):
server = LdapServer({
'port': 3333,
'bind_dn': 'cn=admin,dc=zoldar,dc=net',
'password': '******',
'base': {
'objectclass': ['domain'],
'dn': 'dc=zoldar,dc=net',
'attributes': {'dc': 'zoldar'}
},
'entries': [{
'objectclass': ['domain'],
'dn': 'dc=users,dc=zoldar,dc=net',
'attributes': {'dc': 'users'}
}, {
'objectclass': ['organization'],
'dn': 'o=foocompany,dc=users,dc=zoldar,dc=net',
'attributes': {'o': 'foocompany'}
}],
})
server.start()
dn = "cn=admin,dc=zoldar,dc=net"
pw = "pass1"
srv = ldap3.Server('localhost', port=3333)
conn = ldap3.Connection(srv, user=dn, password=pw, auto_bind=True)
base_dn = 'dc=zoldar,dc=net'
search_filter = '(objectclass=organization)'
attrs = ['o']
conn.search(base_dn, search_filter, attributes=attrs)
self.assertEqual(conn.response, [{
'dn': 'o=foocompany,dc=users,dc=zoldar,dc=net',
'raw_attributes': {'o': [b'foocompany']},
'attributes': {'o': ['foocompany']},
'type': 'searchResEntry'
}])
conn.unbind()
server.stop()
def setUp(self):
super().setUp()
self._ldap_test_server = LdapServer(self.ldap_server_data)
self._ldap_test_server.start()
ldap3_server = ldap3.Server('localhost', port=self._ldap_test_server.config['port'])
self._ldap_connection = ldap3.Connection(
ldap3_server,
user=self._ldap_test_server.config['bind_dn'],
password=self._ldap_test_server.config['password'],
auto_bind=True
)
def __init__(self, methodName):
self.server = LdapServer({
'port': 3333,
'bind_dn': 'cn=admin,dc=cust,dc=local',
'password': '******',
'base': {
'objectclass': ['domain', 'top'],
'dn': 'dc=cust,dc=local',
'attributes': {'dc': 'cust'}
},
'ldifs': [
'tests/user-container.ldif',
'tests/enabled-exchange-user.ldif',
# 'tests/disabled-exchange-user.ldif',
'tests/enabled-non-exchange-user.ldif',
'tests/disabled-non-exchange-user.ldif',
]
})
self.server.start()
super(FilterTests, self).__init__(methodName)
def test_default_with_delay(self):
server = LdapServer(java_delay=1)
server.start()
dn = server.config['bind_dn']
pw = server.config['password']
srv = ldap3.Server('localhost', port=server.config['port'])
conn = ldap3.Connection(srv, user=dn, password=pw, auto_bind=True)
base_dn = server.config['base']['dn']
search_filter = '(objectclass=domain)'
attrs = ['dc']
conn.search(base_dn, search_filter, attributes=attrs)
self.assertEqual(conn.response, [{
'dn': 'dc=example,dc=com',
'raw_attributes': {
'dc': [b'example']
},
'attributes': {
'dc': ['example']
},
'type': 'searchResEntry'
}])
conn.unbind()
server.stop()
def __init__(self):
self.server_port = get_free_port()
self.ldap_server = LdapServer({
'port': self.server_port,
'bind_dn': self.ldap_bind_dn,
'password': self.ldap_bind_password,
'base': {
'objectclass': ['domain'],
'dn': self.ldap_base_dn,
'attributes': {'dc': self.ldap_base_dc}
},
'entries': self.ldap_entries,
})
class LDAPTest(object):
"""
Server fixtures, see https://github.com/zoldar/python-ldap-test
"""
ldap_server_data = NotImplemented
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._ldap_test_server = None
self._ldap_connection = None
def setUp(self):
super().setUp()
self._ldap_test_server = LdapServer(self.ldap_server_data)
self._ldap_test_server.start()
ldap3_server = ldap3.Server('localhost', port=self._ldap_test_server.config['port'])
self._ldap_connection = ldap3.Connection(
ldap3_server,
user=self._ldap_test_server.config['bind_dn'],
password=self._ldap_test_server.config['password'],
auto_bind=True
)
def tearDown(self):
super().tearDown()
self._ldap_test_server.stop()
def test_ldap_connectivity(self):
with make_connection(
'ldap://%s:%d' % ('localhost', self._ldap_test_server.config['port']),
self._ldap_test_server.config['bind_dn'],
'toor'
) as conn:
if not conn.bind():
ok_(False, "Cannot establish connection with LDAP test server")
else:
ok_(True)
class LDAPTest(object):
"""
Server fixtures, see https://github.com/zoldar/python-ldap-test
"""
ldap_server_data = NotImplemented
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._ldap_test_server = None
self._ldap_connection = None
def setUp(self):
super().setUp()
self._ldap_test_server = LdapServer(self.ldap_server_data)
self._ldap_test_server.start()
ldap3_server = ldap3.Server('localhost', port=self._ldap_test_server.config['port'])
self._ldap_connection = ldap3.Connection(
ldap3_server,
user=self._ldap_test_server.config['bind_dn'],
password=self._ldap_test_server.config['password'],
auto_bind=True
)
def tearDown(self):
super().tearDown()
self._ldap_test_server.stop()
def test_ldap_connectivity(self):
with make_connection(
'ldap://%s:%d' % ('localhost', self._ldap_test_server.config['port']),
self._ldap_test_server.config['bind_dn'],
'toor'
) as conn:
if not conn.bind():
ok_(False, "Cannot establish connection with LDAP test server")
else:
ok_(True)
class FilterTests(unittest.TestCase):
def __init__(self, methodName):
self.server = LdapServer({
'port': 3333,
'bind_dn': 'cn=admin,dc=cust,dc=local',
'password': '******',
'base': {
'objectclass': ['domain', 'top'],
'dn': 'dc=cust,dc=local',
'attributes': {'dc': 'cust'}
},
'ldifs': [
'tests/user-container.ldif',
'tests/enabled-exchange-user.ldif',
# 'tests/disabled-exchange-user.ldif',
'tests/enabled-non-exchange-user.ldif',
'tests/disabled-non-exchange-user.ldif',
]
})
self.server.start()
super(FilterTests, self).__init__(methodName)
def teardown_func(self):
self.server.stop()
def test_connectivity(self):
dn = self.server.config['bind_dn']
pw = self.server.config['password']
con = ldap.initialize('ldap://localhost:%s' % (self.server.config['port'],))
con.simple_bind_s(dn, pw)
base_dn = self.server.config['base']['dn']
filter = '(objectclass=*)'
attrs = ['dc']
print con.search_s(base_dn, ldap.SCOPE_SUBTREE, filter, attrs)
def test_config(self):
server = LdapServer({
'port':
3333,
'bind_dn':
'cn=admin,dc=zoldar,dc=net',
'password':
'******',
'base': {
'objectclass': ['domain'],
'dn': 'dc=zoldar,dc=net',
'attributes': {
'dc': 'zoldar'
}
},
'entries': [{
'objectclass': ['domain'],
'dn': 'dc=users,dc=zoldar,dc=net',
'attributes': {
'dc': 'users'
}
}, {
'objectclass': ['organization'],
'dn': 'o=foocompany,dc=users,dc=zoldar,dc=net',
'attributes': {
'o': 'foocompany'
}
}],
})
server.start()
dn = "cn=admin,dc=zoldar,dc=net"
pw = "pass1"
srv = ldap3.Server('localhost', port=3333)
conn = ldap3.Connection(srv, user=dn, password=pw, auto_bind=True)
base_dn = 'dc=zoldar,dc=net'
search_filter = '(objectclass=organization)'
attrs = ['o']
conn.search(base_dn, search_filter, attributes=attrs)
self.assertEqual(conn.response, [{
'dn': 'o=foocompany,dc=users,dc=zoldar,dc=net',
'raw_attributes': {
'o': [b'foocompany']
},
'attributes': {
'o': ['foocompany']
},
'type': 'searchResEntry'
}])
conn.unbind()
server.stop()
def setUpClass(cls):
super(TestLdap, cls).setUpClass()
logging.getLogger('ldap_test').setLevel(logging.ERROR)
cls.mock_server_port = utils.get_free_port()
cls.mock_ldap_url = 'ldap://localhost:{port}'.format(port=cls.mock_server_port)
cls.ldap_server = LdapServer({
'port': cls.mock_server_port,
'bind_dn': LDAP_BIND_DN,
'password': LDAP_BIND_PASSWORD,
'base': {
'objectclass': ['domain'],
'dn': LDAP_BASE_DN,
'attributes': {'dc': LDAP_BASE_DC}
},
'entries': LDAP_ENTRIES,
})
cls.ldap_server.start()
class MockLdapServer(object):
ldap_url = 'ldap://ldap.python-hvac.org'
ldap_group_name = 'vault-users'
ldap_user_name = 'somedude'
ldap_user_password = '******'
ldap_base_dc = 'hvac'
ldap_base_dn = 'dc={dc},dc=network'.format(dc=ldap_base_dc)
ldap_bind_dn = 'cn=admin,{base_dn}'.format(base_dn=ldap_base_dn)
ldap_bind_password = '******'
ldap_users_dn = 'dc=users,{base_dn}'.format(base_dn=ldap_base_dn)
ldap_groups_ou = 'groups'
ldap_groups_dn = 'ou={ou},{base_dn}'.format(ou=ldap_groups_ou,
base_dn=ldap_base_dn)
ldap_login_user_dn = 'uid={username},{users_dn}'.format(
username=ldap_user_name, users_dn=ldap_users_dn)
ldap_entries = [
{
'objectclass': 'domain',
'dn': ldap_users_dn,
'attributes': {
'dc': 'users'
}
},
{
'objectclass': ['inetorgperson', 'posixgroup', 'top'],
'dn': ldap_login_user_dn,
'attributes': {
'uid': ldap_user_name,
'userpassword': ldap_user_password
}
},
{
'objectclass': 'organizationalunit',
'dn': ldap_groups_dn,
'attributes': {
'ou': 'groups',
}
},
{
'objectclass':
'groupofnames',
'dn':
'cn={cn},{groups_dn}'.format(cn=ldap_group_name,
groups_dn=ldap_groups_dn),
'attributes': {
'cn': ldap_group_name,
'member': ldap_login_user_dn,
}
},
]
def __init__(self):
self.server_port = get_free_port()
self.ldap_server = LdapServer({
'port': self.server_port,
'bind_dn': self.ldap_bind_dn,
'password': self.ldap_bind_password,
'base': {
'objectclass': ['domain'],
'dn': self.ldap_base_dn,
'attributes': {
'dc': self.ldap_base_dc
}
},
'entries': self.ldap_entries,
})
@property
def url(self):
return 'ldap://localhost:{port}'.format(port=self.server_port)
def start(self):
self.ldap_server.start()
def stop(self):
self.ldap_server.stop()
# -*- coding: utf-8 -*-
from os.path import abspath, dirname, join
from django.conf import settings
from django.test import TestCase, override_settings
from ldap_test import LdapServer
from ..apps.users.models import User
staticdir = join(dirname(abspath(__file__)), '..', 'static')
mock_server = None
# We don't want to actually call out to ldap for testing, so setup a fake server.
# If we're not actually testing, then there's no point in the overhead.
if settings.TESTING:
mock_server = LdapServer({'base': {'objectclass': 'organization', 'dn': 'dc=tjhsst,dc=edu'},
'ldifs': [join(staticdir, 'ldap', 'base.ldif'), join(staticdir, 'ldap', 'sample_student.ldif')]})
mock_server.start()
def get_mock_port():
return mock_server.config['port'] if mock_server else 0
@override_settings(LDAP_SERVER='ldap://localhost:%d' % get_mock_port(), USE_SASL=False)
class IonTestCase(TestCase):
def login(self):
# We need to add the user to the db before trying to login as them.
User.get_user(username='******').save()
with self.settings(MASTER_PASSWORD='******'):
self.client.login(username='******', password='******')
#!/usr/bin/env python
import ldap
import sys
from ldap_test import LdapServer
if __name__ == "__main__":
server = LdapServer()
try:
server.start()
dn = server.config['bind_dn']
pw = server.config['password']
con = ldap.initialize('ldap://localhost:%s' % (server.config['port'],))
con.simple_bind_s(dn, pw)
base_dn = server.config['base']['dn']
filter = '(objectclass=domain)'
attrs = ['dc']
print con.search_s(base_dn, ldap.SCOPE_SUBTREE, filter, attrs)
finally:
server.stop()
server = LdapServer({
# -*- coding: utf-8 -*-
from django.conf import settings
from django.test import TestCase, override_settings
from ldap_test import LdapServer
from ..apps.users.models import User
mock_server = None
# We don't want to actually call out to ldap for testing, so setup a fake server.
# If we're not actually testing, then there's no point in the overhead.
if settings.TESTING:
mock_server = LdapServer({'base': {'objectclass': 'organization', 'dn': 'dc=tjhsst,dc=edu'},
'ldifs': ['intranet/static/ldap/base.ldif', 'intranet/static/ldap/sample_student.ldif']})
mock_server.start()
def get_mock_port():
return mock_server.config['port'] if mock_server else 0
@override_settings(LDAP_SERVER='ldap://localhost:%d' % get_mock_port(), USE_SASL=False)
class IonTestCase(TestCase):
def login(self):
# We need to add the user to the db before trying to login as them.
User.get_user(username='******').save()
with self.settings(MASTER_PASSWORD='******'):
self.client.login(username='******', password='******')
def test_multiple_instances(self):
servers = {}
for sid in (1, 2):
domain = 'example{0}'.format(sid)
servers[sid] = LdapServer({
'port':
10389 + (sid * 1000),
'bind_dn':
'cn=admin,dc={0},dc=com'.format(domain),
'base': {
'objectclass': ['domain'],
'dn': 'dc={0},dc=com'.format(domain),
'attributes': {
'dc': domain
}
},
})
servers[sid].start()
search_filter = '(objectclass=domain)'
attrs = ['dc']
# server1
dn = servers[1].config['bind_dn']
pw = servers[1].config['password']
base_dn = servers[1].config['base']['dn']
port = servers[1].config['port']
srv = ldap3.Server('localhost', port=port)
conn = ldap3.Connection(srv, user=dn, password=pw, auto_bind=True)
conn.search(base_dn, search_filter, attributes=attrs)
self.assertEqual(conn.response, [{
'dn': 'dc=example1,dc=com',
'raw_attributes': {
'dc': [b'example1']
},
'attributes': {
'dc': ['example1']
},
'type': 'searchResEntry'
}])
conn.unbind()
# server2
dn = servers[2].config['bind_dn']
pw = servers[2].config['password']
base_dn = servers[2].config['base']['dn']
port = servers[2].config['port']
srv = ldap3.Server('localhost', port=port)
conn = ldap3.Connection(srv, user=dn, password=pw, auto_bind=True)
conn.search(base_dn, search_filter, attributes=attrs)
self.assertEqual(conn.response, [{
'dn': 'dc=example2,dc=com',
'raw_attributes': {
'dc': [b'example2']
},
'attributes': {
'dc': ['example2']
},
'type': 'searchResEntry'
}])
conn.unbind()
for server in servers.values():
server.stop()
class MockLdapServer(object):
ldap_url = 'ldap://ldap.python-hvac.org'
ldap_group_name = 'vault-users'
ldap_user_name = 'somedude'
ldap_user_password = '******'
ldap_base_dc = 'hvac'
ldap_base_dn = 'dc={dc},dc=network'.format(dc=ldap_base_dc)
ldap_bind_dn = 'cn=admin,{base_dn}'.format(base_dn=ldap_base_dn)
ldap_bind_password = '******'
ldap_users_dn = 'dc=users,{base_dn}'.format(base_dn=ldap_base_dn)
ldap_groups_ou = 'groups'
ldap_groups_dn = 'ou={ou},{base_dn}'.format(ou=ldap_groups_ou, base_dn=ldap_base_dn)
ldap_login_user_dn = 'uid={username},{users_dn}'.format(username=ldap_user_name, users_dn=ldap_users_dn)
ldap_entries = [
{
'objectclass': 'domain',
'dn': ldap_users_dn,
'attributes': {
'dc': 'users'
}
},
{
'objectclass': ['inetorgperson', 'posixgroup', 'top'],
'dn': ldap_login_user_dn,
'attributes': {
'uid': ldap_user_name,
'userpassword': ldap_user_password
}
},
{
'objectclass': 'organizationalunit',
'dn': ldap_groups_dn,
'attributes': {
'ou': 'groups',
}
},
{
'objectclass': 'groupofnames',
'dn': 'cn={cn},{groups_dn}'.format(cn=ldap_group_name, groups_dn=ldap_groups_dn),
'attributes': {
'cn': ldap_group_name,
'member': ldap_login_user_dn,
}
},
]
def __init__(self):
self.server_port = get_free_port()
self.ldap_server = LdapServer({
'port': self.server_port,
'bind_dn': self.ldap_bind_dn,
'password': self.ldap_bind_password,
'base': {
'objectclass': ['domain'],
'dn': self.ldap_base_dn,
'attributes': {'dc': self.ldap_base_dc}
},
'entries': self.ldap_entries,
})
@property
def url(self):
return 'ldap://localhost:{port}'.format(port=self.server_port)
def start(self):
self.ldap_server.start()
def stop(self):
self.ldap_server.stop()
server = LdapServer({
'port':
3333,
'bind_dn':
'cn=admin,dc=luochunhui,dc=com',
'password':
'******',
'base': {
'objectclass': ['domain'],
'dn': 'dc=luochunhui,dc=com',
'attributes': {
'dc': 'luochunhui'
}
},
'entries': [
{
'objectclass': 'domain',
'dn': 'dc=users,dc=luochunhui,dc=com',
'attributes': {
'dc': 'users'
}
},
{
'objectclass': 'organization',
'dn': 'o=foocompany,dc=users,dc=luochunhui,dc=com',
'attributes': {
'o': 'foocompany'
}
},
]
})
