def setUp(self):
ret_chn = ReturnChannel(stdout_callback, {})
command_list = load_modules()
self.config = Config('help', '', command_list, [], ret_chn, 'shell')
self.connector = LDAPConnector(self.config)
self.config.import_custom_options()
self.init_config()
class LDAPConnectorTests(unittest.TestCase):
def setUp(self):
ret_chn = ReturnChannel(stdout_callback, {})
command_list = load_modules()
self.config = Config('help', '', command_list, [], ret_chn, 'shell')
self.connector = LDAPConnector(self.config)
self.config.import_custom_options()
self.init_config()
def init_config(self):
self.config['ldap_method'] = 'LDAP'
self.config['page_size'] = 1
self.config['bind_dn'] = 'cn=foo,dc=example,dc=com'
self.config['group_mapping'] = {
"scientists": "group1",
"mathematicians": "group2",
"analyst": "group3"
}
self.david = 'CN=David Hilbert,CN=Users,DC=example,DC=org'
self.jon = 'CN=Jon Snow,CN=Users,DC=example,DC=org'
self.james = 'CN=James Bond,CN=Users,DC=example,DC=org'
self.users = [self.david, self.jon]
def expected_directory_users(self):
expected_users = {}
for user, group in zip(self.users, ['mathematicians', 'scientists']):
expected_users[DIRECTORY[user]['mail'][0]] = {
'full_name': DIRECTORY[user]['cn'][0],
'groups': [group],
'last_name': DIRECTORY[user]['sn'][0],
'email': DIRECTORY[user]['mail'][0],
'exists': False
}
return expected_users
def test_translate_ldap_group_to_sde_group(self):
self.connector._groups = {
'g1': [1, 2, 3],
'g2': [4, 5, 6]
}
mapping = {'mathematicians': 'g1', 'scientists': 'g2'}
ldap_groups = ['mathematicians', 'programmers']
expected = [[1, 2, 3]]
actual = self.connector.translate_ldap_group_to_sde_group(ldap_groups, mapping)
self.assertEqual(actual, expected)
def test_calculate_name(self):
user = {
'first_name': 'John',
'last_name': 'Smith',
'full_name': 'John Smith'
}
new_user = self.connector.calculate_name(user)
self.assertEqual(user, new_user)
# Missing first name and last name is inferred
for missing_field in ['first_name', 'last_name']:
other_user = user.copy()
del other_user[missing_field]
new_user = self.connector.calculate_name(other_user)
self.assertEqual(user, new_user)
# only full name present with space in it
other_user = {'full_name': 'John Smith'}
new_user = self.connector.calculate_name(other_user)
self.assertEqual(user, new_user)
# only full name present - no spaces
other_user = {'full_name': 'Aouda'}
expected_user = {
'first_name': 'Aouda',
'last_name': 'Aouda',
'full_name': 'Aouda'
}
new_user = self.connector.calculate_name(other_user)
self.assertEqual(new_user, expected_user)
# either first or last name only
for field in ['first_name', 'last_name']:
other_user = {field: 'Aouda'}
new_user = self.connector.calculate_name(other_user)
self.assertEqual(new_user['first_name'], new_user['last_name'])
def test_filter_groups(self):
groups = {
'g1': ['a', 'b', 'c'],
'g2': ['d', 'e', 'f']
}
# no filtering
actual = self.connector.filter_groups(groups, {})
self.assertEqual(actual, groups)
# only whitelisted groups should appear
actual = self.connector.filter_groups(groups, {'groups': ['g1']})
def test_filter_users(self):
# only those with emails are returned
groups = {
'mathematicians': [DIRECTORY[self.david]],
'scientists': [DIRECTORY[self.jon]],
'spies': [DIRECTORY[self.james]]
}
self.connector.initialize()
actual = self.connector.filter_users(groups, {})
expected = self.expected_directory_users()
self.assertEqual(actual, expected)
# only whitelisted ones are returned
user = self.jon
email = DIRECTORY[user]['mail'][0]
filters = {'users': [email]}
actual = self.connector.filter_users(groups, filters)
expected = {
email: {
'full_name': DIRECTORY[user]['cn'][0],
'groups': ['scientists'],
'last_name': DIRECTORY[user]['sn'][0],
'email': DIRECTORY[user]['mail'][0],
'exists': False
}
}
self.assertEqual(actual, expected)
def test_get_users_diff(self):
dict_a = {'a': 1, 'b': 2, 'c': 3}
dict_b = {'c': 1, 'd': 2, 'e': 3}
actual = self.connector._get_users_diff(dict_a, dict_b)
expected = (
dict_a,
dict_b,
set(['c']),
set(['d', 'e']),
set(['a', 'b'])
)
self.assertEquals(actual, expected)
