def test_search_and_delete_entry(self):
add_user(self.connection, testcase_id, 'del1', attributes={'givenName': 'givenname-delete'})
read_only_entry = self.get_entry('del1')
self.assertEqual(read_only_entry.entry_status, STATUS_READ)
writable_entry = read_only_entry.entry_writable('inetorgperson')
self.assertEqual(writable_entry.entry_status, STATUS_WRITABLE)
writable_entry.entry_delete()
self.assertEqual(writable_entry.entry_status, STATUS_READY_FOR_DELETION)
result = writable_entry.entry_commit_changes()
self.assertEqual(writable_entry.entry_status, STATUS_DELETED)
self.assertTrue(result)
counter = 20
while counter > 0: # waits for at maximum 20 times - delete operation can take some time to complete
result = self.connection.search(search_base=test_base, search_filter='(' + test_name_attr + '=' + testcase_id + 'del1)', attributes=[test_name_attr, 'givenName'])
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
entries = self.connection._get_entries(response)
else:
result = self.connection.result
entries = self.connection.entries
if len(entries) == 0:
break
sleep(3)
counter -= 1
self.assertEqual(result['description'], 'success')
self.assertEqual(len(entries), 0)
self.compare_entries(read_only_entry, writable_entry)
def test_check_groups_memberships(self):
if test_server_type == 'EDIR' and not self.connection.strategy.pooled and not self.connection.strategy.no_real_dsa:
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'user-1'))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'user-2'))
self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'group-1'))
self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'group-2'))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'user-3'))
self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'group-3'))
self.connection.extend.novell.add_members_to_groups((self.delete_at_teardown[0][0], self.delete_at_teardown[1][0]),
self.delete_at_teardown[2][0],
fix=True,
transaction=True)
self.connection.extend.novell.add_members_to_groups((self.delete_at_teardown[0][0], self.delete_at_teardown[1][0]),
self.delete_at_teardown[3][0],
fix=True,
transaction=True)
# valid users in valid groups
result = self.connection.extend.novell.check_groups_memberships((self.delete_at_teardown[0][0], self.delete_at_teardown[1][0]), (self.delete_at_teardown[2][0],self.delete_at_teardown[3][0]))
self.assertTrue(result)
# invalid users in valid groups
result = self.connection.extend.novell.check_groups_memberships((self.delete_at_teardown[0][0], self.delete_at_teardown[3][0]), (self.delete_at_teardown[2][0],self.delete_at_teardown[3][0]))
self.assertFalse(result)
# invalid users in invalid groups
result = self.connection.extend.novell.check_groups_memberships((self.delete_at_teardown[0][0], self.delete_at_teardown[4][0]), (self.delete_at_teardown[2][0], self.delete_at_teardown[5][0]))
self.assertFalse(result)
def setUp(self):
global testcase_id
testcase_id = random_id()
self.connection = get_connection()
self.delete_at_teardown = []
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'ldif-content-1'))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'ldif-content-2'))
def test_find_entry_with_text_index_match(self):
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'mat-1'))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'mat-2'))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'mat-3'))
o = ObjectDef('inetOrgPerson')
o += AttrDef('cn', 'Common Name')
o += AttrDef('sn', 'Surname')
o += AttrDef(test_multivalued_attribute, 'Given Name')
query_text = 'Common Name:=' + testcase_id + 'mat-*'
r = Reader(self.connection, o, test_base, query_text)
results = r.search()
self.assertEqual(len(results), 3)
try: # multiple matches
e = r['match']
except KeyError:
pass
e = r['-2'] # exact match
self.assertTrue('mat-2' in e.entry_dn)
try:
e = r['no-match'] # no match
except KeyError:
pass
def setUp(self):
global testcase_id
testcase_id = random_id()
self.connection = get_connection()
self.delete_at_teardown = []
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'controls-1', attributes={'givenName': 'given name-1'}))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'controls-2', attributes={'givenName': 'given name-2'}))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'controls-3', attributes={'givenName': 'given name-3'}))
def test_paged_search_accumulator_with_schema(self):
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'mat-1'))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'mat-2'))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'mat-3'))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'mat-4'))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'mat-5'))
r = Reader(self.connection, 'inetorgperson', test_base, 'cn:=' + testcase_id + 'mat-*')
entries = r.search_paged(2, True, generator=False, attributes=['cn'])
self.assertEqual(len(entries), 5)
def test_match_in_single_attribute_with_schema(self):
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'mat-1', attributes={test_singlevalued_attribute: 'FALSE'}))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'mat-2', attributes={test_singlevalued_attribute: 'FALSE'}))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'mat-3', attributes={test_singlevalued_attribute: 'TRUE'}))
r = Reader(self.connection, 'inetorgperson', test_base, 'cn:=' + testcase_id + 'mat-*')
results = r.search()
self.assertEqual(len(results), 3)
e = r.match(test_singlevalued_attribute, 'FALSE')
self.assertEqual(len(e), 2)
e = r.match(test_singlevalued_attribute, 'fAlSe')
self.assertEqual(len(e), 2)
def test_search_string_guid(self):
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'sea-16', attributes={'givenName': testcase_id + 'givenname-16'}))
if test_server_type == 'EDIR':
result = self.connection.search(search_base=test_base, search_filter='(givenname=' + testcase_id + 'givenname-16)', attributes=[test_name_attr, 'sn', 'guid'])
elif test_server_type == 'AD': # not tested on AD yet
result = self.connection.search(search_base=test_base, search_filter='(givenname=' + testcase_id + 'givenname-16)', attributes=[test_name_attr, 'sn', 'objectGuid'])
else: # not tested on other kind of servers
return
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
else:
response = self.connection.response
result = self.connection.result
self.assertEqual(result['description'], 'success')
self.assertEqual(len(response), 1)
if test_server_type == 'EDIR':
result = self.connection.search(search_base=test_base, search_filter='(guid=' + response[0]['attributes']['guid'] + ')', attributes=[test_name_attr, 'sn'])
elif test_server_type == 'AD': # not tested on AD yet
result = self.connection.search(search_base=test_base, search_filter='(objectguid=' + response[0]['attributes']['objectguid'] + ')', attributes=[test_name_attr, 'sn'])
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
else:
response = self.connection.response
result = self.connection.result
self.assertEqual(result['description'], 'success')
self.assertEqual(len(response), 1)
if test_server_type == 'EDIR':
self.assertEqual(response[0]['attributes'][test_name_attr][0], testcase_id + 'sea-16')
elif test_server_type == 'AD':
self.assertEqual(response[0]['attributes'][test_name_attr], testcase_id + 'sea-16')
def test_search_object(self):
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'abstract-1'))
o = ObjectDef(['inetorgPerson', 'person'], self.connection)
r = Reader(self.connection, o, test_base, '(cn=' + testcase_id + 'abstract-1)')
r.search(attributes='cn') # AD returns operationError for reading some atributes
self.assertEqual(len(r), 1)
self.assertEqual(r.entries[0].cn, testcase_id + 'abstract-1')
def test_search_filter_with_object_class(self):
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'abs-1'))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'abs-2'))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'abs-3'))
self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'abs-grp', self.delete_at_teardown))
reverse = lambda a, e: e[::-1]
o = ObjectDef('inetOrgPerson')
o += AttrDef('cn', 'Common Name')
o += AttrDef('sn', 'Surname')
o += AttrDef(test_multivalued_attribute, 'Given Name', post_query=reverse)
query_text = 'Common Name:=' + testcase_id + 'abs-*'
r = Reader(self.connection, o, test_base, query_text)
results = r.search()
self.assertEqual(len(results), 3)
def test_modify_operation_from_bytes_literal(self):
single = b'abc'
multi = [b'abc', b'def']
single_mod = b'cba'
multi_mod = [b'cba', b'fed']
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'byt-12', attributes={test_singlevalued_attribute: single, test_multivalued_attribute: multi}, test_bytes=True))
self.assertEqual('success', self.delete_at_teardown[0][1]['description'])
result = self.connection.search(self.delete_at_teardown[0][0], '(objectclass=*)', BASE, attributes=[test_singlevalued_attribute, test_multivalued_attribute])
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
else:
response = self.connection.response
self.assertEqual(len(response), 1)
self.assertEqual(response[0]['raw_attributes'][test_singlevalued_attribute], [single])
self.assertEqual(sorted(response[0]['raw_attributes'][test_multivalued_attribute]), sorted(multi))
self.connection.modify(self.delete_at_teardown[0][0], {test_singlevalued_attribute: (MODIFY_REPLACE, single_mod), test_multivalued_attribute: (MODIFY_ADD, multi_mod)})
if not self.connection.strategy.sync:
sleep(2)
result = self.connection.search(self.delete_at_teardown[0][0], '(objectclass=*)', BASE, attributes=[test_singlevalued_attribute, test_multivalued_attribute])
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
else:
response = self.connection.response
self.assertEqual(response[0]['raw_attributes'][test_singlevalued_attribute], [single_mod])
self.assertEqual(sorted(response[0]['raw_attributes'][test_multivalued_attribute]), sorted(multi + multi_mod))
def test_modify_operation_from_byte_values(self):
if str is not bytes: # integer list to bytes works only in Python 3
single = make_bytes([195, 160, 195, 168, 195, 172, 195, 178, 195, 185])
multi = [make_bytes([195, 160, 195, 168, 195, 172]), make_bytes([195, 178, 195, 185])]
single_mod = make_bytes([195, 185, 195, 178, 195, 172, 195, 168, 195, 160])
multi_mod = [make_bytes([195, 172, 195, 168, 195, 160]), make_bytes([195, 185, 195, 178])]
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'byt-13', attributes={test_singlevalued_attribute: single, test_multivalued_attribute: multi}, test_bytes=True))
self.assertEqual('success', self.delete_at_teardown[0][1]['description'])
result = self.connection.search(self.delete_at_teardown[0][0], '(objectclass=*)', BASE, attributes=[test_singlevalued_attribute, test_multivalued_attribute])
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
else:
response = self.connection.response
self.assertEqual(len(response), 1)
self.assertEqual(response[0]['raw_attributes'][test_singlevalued_attribute], [single])
self.assertEqual(sorted(response[0]['raw_attributes'][test_multivalued_attribute]), sorted(multi))
self.connection.modify(self.delete_at_teardown[0][0], {test_singlevalued_attribute: (MODIFY_REPLACE, single_mod), test_multivalued_attribute: (MODIFY_ADD, multi_mod)})
if not self.connection.strategy.sync:
sleep(2)
result = self.connection.search(self.delete_at_teardown[0][0], '(objectclass=*)', BASE, attributes=[test_singlevalued_attribute, test_multivalued_attribute])
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
else:
response = self.connection.response
self.assertEqual(response[0]['raw_attributes'][test_singlevalued_attribute], [single_mod])
self.assertEqual(sorted(response[0]['raw_attributes'][test_multivalued_attribute]), sorted(multi + multi_mod))
def test_modify_operation_from_bytearray_unicode_literal(self):
single = make_bytearray(u'\u00e0\u00e8\u00ec\u00f2\u00f9', 'utf-8')
multi = [make_bytearray(u'\u00e0\u00e8\u00ec', 'utf-8'), make_bytearray(u'\u00f2\u00f9', 'utf-8')]
single_mod = make_bytearray(u'\u00f9\u00f2\u00ec\u00e8\u00e0', 'utf-8')
multi_mod = [make_bytearray(u'\u00ec\u00e8\u00e0', 'utf-8'), make_bytearray('\u00f9\u00f2', 'utf-8')]
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'byt-18', attributes={test_singlevalued_attribute: single, test_multivalued_attribute: multi}, test_bytes=True))
self.assertEqual('success', self.delete_at_teardown[0][1]['description'])
result = self.connection.search(self.delete_at_teardown[0][0], '(objectclass=*)', BASE, attributes=[test_singlevalued_attribute, test_multivalued_attribute])
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
else:
response = self.connection.response
self.assertEqual(len(response), 1)
self.assertEqual(response[0]['raw_attributes'][test_singlevalued_attribute], [single])
self.assertEqual(sorted(response[0]['raw_attributes'][test_multivalued_attribute]), sorted(multi))
self.connection.modify(self.delete_at_teardown[0][0], {test_singlevalued_attribute: (MODIFY_REPLACE, single_mod), test_multivalued_attribute: (MODIFY_ADD, multi_mod)})
if not self.connection.strategy.sync:
sleep(2)
result = self.connection.search(self.delete_at_teardown[0][0], '(objectclass=*)', BASE, attributes=[test_singlevalued_attribute, test_multivalued_attribute])
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
else:
response = self.connection.response
self.assertEqual(response[0]['raw_attributes'][test_singlevalued_attribute], [single_mod])
self.assertEqual(sorted(response[0]['raw_attributes'][test_multivalued_attribute]), sorted(multi + multi_mod))
def test_modify_operation_from_bytearray_unicode_name(self):
if str is not bytes: # works only in python 3
single = make_bytearray(u'\N{LATIN SMALL LETTER A WITH GRAVE}\N{LATIN SMALL LETTER E WITH GRAVE}\N{LATIN SMALL LETTER I WITH GRAVE}\N{LATIN SMALL LETTER O WITH GRAVE}\N{LATIN SMALL LETTER U WITH GRAVE}', 'utf-8')
multi = [make_bytearray(u'\N{LATIN SMALL LETTER A WITH GRAVE}\N{LATIN SMALL LETTER E WITH GRAVE}\N{LATIN SMALL LETTER I WITH GRAVE}', 'utf-8'), make_bytearray('\N{LATIN SMALL LETTER O WITH GRAVE}\N{LATIN SMALL LETTER U WITH GRAVE}', 'utf-8')]
single_mod = make_bytearray('\N{LATIN SMALL LETTER U WITH GRAVE}\N{LATIN SMALL LETTER O WITH GRAVE}\N{LATIN SMALL LETTER I WITH GRAVE}\N{LATIN SMALL LETTER E WITH GRAVE}\N{LATIN SMALL LETTER A WITH GRAVE}', 'utf-8')
multi_mod = [make_bytearray('\N{LATIN SMALL LETTER I WITH GRAVE}\N{LATIN SMALL LETTER E WITH GRAVE}\N{LATIN SMALL LETTER A WITH GRAVE}', 'utf-8'), make_bytearray('\N{LATIN SMALL LETTER U WITH GRAVE}\N{LATIN SMALL LETTER O WITH GRAVE}', 'utf-8')]
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'byt-19', attributes={test_singlevalued_attribute: single, test_multivalued_attribute: multi}, test_bytes=True))
self.assertEqual('success', self.delete_at_teardown[0][1]['description'])
result = self.connection.search(self.delete_at_teardown[0][0], '(objectclass=*)', BASE, attributes=[test_singlevalued_attribute, test_multivalued_attribute])
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
else:
response = self.connection.response
self.assertEqual(len(response), 1)
self.assertEqual(response[0]['raw_attributes'][test_singlevalued_attribute], [single])
self.assertEqual(sorted(response[0]['raw_attributes'][test_multivalued_attribute]), sorted(multi))
self.connection.modify(self.delete_at_teardown[0][0], {test_singlevalued_attribute: (MODIFY_REPLACE, single_mod), test_multivalued_attribute: (MODIFY_ADD, multi_mod)})
if not self.connection.strategy.sync:
sleep(2)
result = self.connection.search(self.delete_at_teardown[0][0], '(objectclass=*)', BASE, attributes=[test_singlevalued_attribute, test_multivalued_attribute])
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
else:
response = self.connection.response
self.assertEqual(response[0]['raw_attributes'][test_singlevalued_attribute], [single_mod])
self.assertEqual(sorted(response[0]['raw_attributes'][test_multivalued_attribute]), sorted(multi + multi_mod))
def test_remove_member_from_group_transactional(self):
if test_server_type == 'EDIR' and not self.connection.strategy.pooled and not self.connection.strategy.no_real_dsa:
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'user-5'))
self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'group-5', self.delete_at_teardown))
self.connection.extend.novell.add_members_to_groups(self.delete_at_teardown[0][0],
self.delete_at_teardown[1][0],
fix=True,
transaction=True)
result = self.connection.search(self.delete_at_teardown[0][0], '(objectclass=*)', attributes=['securityEquals', 'groupMembership'])
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
else:
response, result = self.connection.response, self.connection.result
if response:
self.assertTrue(self.delete_at_teardown[1][0] in (response[0]['attributes']['securityEquals'] if 'securityEquals' in response[0]['attributes'] else []))
self.assertTrue(self.delete_at_teardown[1][0] in (response[0]['attributes']['groupMembership'] if 'groupMembership' in response[0]['attributes'] else []))
else:
self.assertFalse(True, self.delete_at_teardown[1][0] + ' not found')
result = self.connection.search(self.delete_at_teardown[1][0], '(objectclass=*)', attributes=['member', 'equivalentToMe'])
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
else:
response, result = self.connection.response, self.connection.result
if response:
self.assertTrue(self.delete_at_teardown[0][0] in (response[0]['attributes']['member'] if 'member' in response[0]['attributes'] else []))
self.assertTrue(self.delete_at_teardown[0][0] in (response[0]['attributes']['equivalentToMe'] if 'equivalentToMe' in response[0]['attributes'] else []))
else:
self.assertFalse(True, self.delete_at_teardown[0][0] + ' not found')
self.connection.extend.novell.remove_members_from_groups(self.delete_at_teardown[0][0],
self.delete_at_teardown[1][0],
fix=False,
transaction=False)
result = self.connection.search(self.delete_at_teardown[0][0], '(objectclass=*)', attributes=['securityEquals', 'groupMembership'])
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
else:
response, result = self.connection.response, self.connection.result
if response:
self.assertTrue(self.delete_at_teardown[1][0] not in (response[0]['attributes']['securityEquals'] if 'securityEquals' in response[0]['attributes'] else []))
self.assertTrue(self.delete_at_teardown[1][0] not in (response[0]['attributes']['groupMembership'] if 'groupMembership' in response[0]['attributes'] else []))
else:
self.assertFalse(True, self.delete_at_teardown[1][0] + ' not found')
result = self.connection.search(self.delete_at_teardown[1][0], '(objectclass=*)', attributes=['member', 'equivalentToMe'])
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
else:
response, result = self.connection.response, self.connection.result
if response:
self.assertTrue(self.delete_at_teardown[0][0] not in (response[0]['attributes']['member'] if 'member' in response[0]['attributes'] else []))
self.assertTrue(self.delete_at_teardown[0][0] not in (response[0]['attributes']['equivalentToMe'] if 'equivalentToMe' in response[0]['attributes'] else []))
else:
self.assertFalse(True, self.delete_at_teardown[0][0] + ' not found')
def test_add_binary(self):
bin1 = open('512b-rsa-example-cert.der','rb')
bin2 = open('1024b-rsa-example-cert.der','rb')
der_certificates = [bin1.read(), bin2.read()]
bin1.close()
bin2.close()
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'add-operation-4', attributes={'userCertificate;binary': der_certificates}))
self.assertEqual('success', self.delete_at_teardown[0][1]['description'])
def test_search_with_pre_query(self):
change = lambda attr, value: testcase_id + 'abs-*'
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'abs-7'))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'abs-8'))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'abs-9'))
self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'abstract-group', self.delete_at_teardown))
ou = ObjectDef('inetOrgPerson')
ou += AttrDef('cn', 'Common Name', pre_query=change)
ou += AttrDef('sn', 'Surname')
ou += AttrDef(test_multivalued_attribute, 'Given Name')
ou += AttrDef('ACL')
qu = 'Common Name := bug'
ru = Reader(self.connection, ou, test_base, qu)
lu = ru.search()
self.assertEqual(len(lu), 3)
def test_paged_search_generator_with_schema_base_object(self):
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'mat-1'))
r = Reader(self.connection, 'inetorgperson', self.delete_at_teardown[0][0])
entries = r.search_paged(2, True, generator=True, attributes=['cn'])
cont = 0
for _ in entries:
cont += 1
self.assertEqual(cont, 1)
def test_search_simple_paged(self):
if not self.connection.strategy.pooled and not self.connection.strategy.no_real_dsa:
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'sea-5', attributes={'givenName': 'givenname-3'}))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'sea-6', attributes={'givenName': 'givenname-4'}))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'sea-7', attributes={'givenName': 'givenname-5'}))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'sea-8', attributes={'givenName': 'givenname-6'}))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'sea-9', attributes={'givenName': 'givenname-7'}))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'sea-10', attributes={'givenName': 'givenname-8'}))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'sea-11', attributes={'givenName': 'givenname-9'}))
paged_size = 4
total_entries = 0
result = self.connection.search(search_base=test_base, search_filter='(' + test_name_attr + '=' + testcase_id + '*)', search_scope=SUBTREE, attributes=[test_name_attr, 'givenName'], paged_size=paged_size)
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
else:
response = self.connection.response
result = self.connection.result
self.assertEqual(result['description'], 'success')
self.assertEqual(len(response), paged_size)
total_entries += len(response)
cookie = result['controls']['1.2.840.113556.1.4.319']['value']['cookie']
while cookie:
result = self.connection.search(search_base=test_base, search_filter='(' + test_name_attr + '=' + testcase_id + '*)', search_scope=SUBTREE, attributes=[test_name_attr, 'givenName'], paged_size=paged_size, paged_cookie=cookie)
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
else:
response = self.connection.response
result = self.connection.result
self.assertEqual(result['description'], 'success')
total_entries += len(response)
self.assertTrue(len(response) <= paged_size)
cookie = result['controls']['1.2.840.113556.1.4.319']['value']['cookie']
self.assertEqual(total_entries, 11)
def test_modify_dn_operation(self):
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'modify-dn-1'))
result = self.connection.modify_dn(self.delete_at_teardown[0][0], test_name_attr + '=' + testcase_id + 'modified-dn-1')
if not self.connection.strategy.sync:
_, result = self.connection.get_response(result)
else:
result = self.connection.result
self.delete_at_teardown[0] = (self.delete_at_teardown[0][0].replace('modify-dn-1', 'modified-dn-1'), self.delete_at_teardown[0][1])
self.assertEqual(result['description'], 'success')
def test_add_members_to_groups(self):
if test_server_type == 'EDIR' and not self.connection.strategy.pooled and not self.connection.strategy.no_real_dsa:
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'user-2'))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'user-3'))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'user-4'))
self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'group-2', self.delete_at_teardown))
self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'group-3'))
self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'group-4'))
self.connection.extend.novell.add_members_to_groups([self.delete_at_teardown[0][0],
self.delete_at_teardown[1][0],
self.delete_at_teardown[2][0]],
[self.delete_at_teardown[3][0],
self.delete_at_teardown[4][0],
self.delete_at_teardown[5][0]],
fix=True,
transaction=False
)
for i in range(0, 2):
result = self.connection.search(self.delete_at_teardown[i][0], '(objectclass=*)', attributes=['securityEquals', 'groupMembership'])
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
else:
response, result = self.connection.response, self.connection.result
if response:
for j in range(3, 5):
self.assertTrue(self.delete_at_teardown[j][0] in (response[0]['attributes']['securityEquals'] if 'securityEquals' in response[0]['attributes'] else []))
self.assertTrue(self.delete_at_teardown[j][0] in (response[0]['attributes']['groupMembership'] if 'groupMembership' in response[0]['attributes'] else []))
else:
self.assertFalse(True, self.delete_at_teardown[i][0] + ' not found')
for j in range(3, 5):
result = self.connection.search(self.delete_at_teardown[j][0], '(objectclass=*)', attributes=['member', 'equivalentToMe'])
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
else:
response, result = self.connection.response, self.connection.result
if response:
for i in range(0, 2):
self.assertTrue(self.delete_at_teardown[i][0] in (response[0]['attributes']['member'] if 'member' in response[0]['attributes'] else []))
self.assertTrue(self.delete_at_teardown[i][0] in (response[0]['attributes']['equivalentToMe'] if 'equivalentToMe' in response[0]['attributes'] else []))
else:
self.assertFalse(True, self.delete_at_teardown[j][0] + ' not found')
def test_search_with_None_default(self):
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'abs-12'))
ou = ObjectDef('inetOrgPerson')
ou += AttrDef('cn', 'CommonName')
ou += AttrDef('employeeType', key='Employee', default=None)
qu = 'CommonName := ' + testcase_id + 'abs-12'
ru = Reader(self.connection, ou, test_base, qu)
lu = ru.search()
self.assertEqual(lu[0].employee.value, None)
def test_valid_attribute(self):
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'chk-2', attributes={'givenName': 'given-name-2'}))
result = self.connection.search(search_base=test_base, search_filter='(' + test_name_attr + '=' + testcase_id + 'chk-2)', attributes=[test_name_attr, 'givenName'])
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
else:
response = self.connection.response
result = self.connection.result
self.assertEqual(result['description'], 'success')
self.assertEqual(len(response), 1)
def test_modify_operation_from_bytes_for_objectclass(self):
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'byt-29', test_bytes=True))
self.assertEqual('success', self.delete_at_teardown[0][1]['description'])
result = self.connection.modify(self.delete_at_teardown[0][0], {'objectClass': (MODIFY_REPLACE, [b'top', b'organizationalunit'])})
if not self.connection.strategy.sync:
sleep(2)
response, result = self.connection.get_response(result)
else:
result = self.connection.result
self.assertTrue(result['description'], ['objectClassViolation', 'objectClassModsProhibited'])
def test_compare_false_operation_with_bytes(self):
single = make_bytes('àèìòù', 'utf-8')
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'byt-11', attributes={test_singlevalued_attribute: single}, test_bytes=True))
self.assertEqual('success', self.delete_at_teardown[0][1]['description'])
result = self.connection.compare(self.delete_at_teardown[0][0], test_singlevalued_attribute, 'invalid')
if not self.connection.strategy.sync:
_, result = self.connection.get_response(result)
else:
result = self.connection.result
self.assertEqual(result['description'], 'compareFalse')
def test_search_with_dereference(self):
reverse = lambda a, e: e[::-1]
def raise_parentheses_rank(_, l):
up = {'(': '[', ')': ']', '[': '{', ']': '}', '{': '<', '}': '>'}
r = []
for e in l:
s = ''
for c in e:
s += up[c] if c in up else c
r.append(s)
return r
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'abs-4'))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'abs-5'))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'abs-6'))
self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'abstract-group', self.delete_at_teardown))
ou = ObjectDef('inetOrgPerson')
ou += AttrDef('cn', 'Common Name', post_query=reverse)
ou += AttrDef('sn', 'Surname')
ou += AttrDef(test_multivalued_attribute, 'Given Name', post_query=raise_parentheses_rank)
ou += AttrDef('ACL')
qu = 'Common Name: ' + testcase_id + 'abs-*'
ru = Reader(self.connection, ou, test_base, qu)
lu = ru.search()
self.assertEqual(len(lu), 3)
og = ObjectDef('groupOfNames')
og += AttrDef('member', dereference_dn=ou)
og += 'cn'
qg = 'cn := ' + testcase_id + 'abstract-group'
rg = Reader(self.connection, og, test_base, qg)
lg = rg.search()
self.assertEqual(len(lg), 1)
eg = lg[0]
mg = eg.member
self.assertEqual(len(mg), 3)
ug = eg.member[0]
self.assertTrue(str(ug.surname) in ['abs-4', 'abs-5', 'abs-6'])
def test_match_in_single_attribute(self):
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'mat-1', attributes={test_multivalued_attribute: ['givenname-1', 'givenname-1a']}))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'mat-2', attributes={test_multivalued_attribute: ['givenname-2', 'givenname-2a']}))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'mat-3', attributes={test_multivalued_attribute: ['givenname-3', 'givenname-3a']}))
o = ObjectDef('inetOrgPerson')
o += AttrDef('cn', 'Common Name')
o += AttrDef('sn', 'Surname')
o += AttrDef(test_multivalued_attribute, 'Given Name')
query_text = 'Common Name:=' + testcase_id + 'mat-*'
r = Reader(self.connection, o, test_base, query_text)
results = r.search()
self.assertEqual(len(results), 3)
e = r.match('Given Name', 'name') # multiple matches
self.assertEqual(len(e), 3)
e = r.match('Given Name', '2a') # single match
self.assertEqual(len(e), 1)
e = r.match('Given Name', 'no-match') # no match
self.assertEqual(len(e), 0)
def test_add_operation_from_bytes(self):
single = make_bytes('àèìòù', 'utf-8')
multi = [make_bytes('àèì', 'utf-8'), make_bytes('òù', 'utf-8')]
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'byt-2', attributes={test_singlevalued_attribute: single, test_multivalued_attribute: multi}, test_bytes=True))
self.assertEqual('success', self.delete_at_teardown[0][1]['description'])
result = self.connection.search(self.delete_at_teardown[0][0], '(objectclass=*)', BASE, attributes=[test_singlevalued_attribute, test_multivalued_attribute])
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
else:
response = self.connection.response
self.assertEqual(len(response), 1)
self.assertEqual(response[0]['raw_attributes'][test_singlevalued_attribute], [single])
def test_modify_entry_with_attrdef_with_friendly_name(self):
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'new-9', attributes={test_multivalued_attribute: testcase_id + 'friendly-attr-name-1'}))
a = AttrDef(name=test_multivalued_attribute, key='myname')
o = ObjectDef('inetorgperson')
o += a
r = Reader(self.connection, o, test_base, 'myname:=' + testcase_id + 'friendly*')
r.search()
self.assertTrue(r[0].myname, testcase_id + 'friendly-attr-name-1')
w = Writer.from_cursor(r)
e = w[0]
e.myname += 'xyz'
w.commit()
self.assertTrue('xyz' in e.myname)
def test_modify_existing_password_as_administrator(self):
if test_server_type == 'AD' and test_strategy != REUSABLE:
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'pwd-3', attributes={'givenName': 'pwd-3'}))
dn = self.delete_at_teardown[-1][0]
new_password = '******'
result = self.connection.extend.microsoft.modify_password(dn, new_password)
self.assertEqual(result, True)
# creates a second connection and tries to bind with the new password
test_connection = get_connection(bind=False, authentication=SIMPLE, simple_credentials=(dn, new_password))
test_connection.bind()
connected_user = test_connection.extend.standard.who_am_i()
test_connection.unbind()
self.assertTrue('pwd-3' in connected_user)
def test_add(self):
self.delete_at_teardown.append(
add_user(self.connection, testcase_id, 'add-operation-1'))
self.assertEqual('success',
self.delete_at_teardown[0][1]['description'])
def test_remove_member_from_group_transactional(self):
if test_server_type == 'EDIR' and not self.connection.strategy.pooled and not self.connection.strategy.no_real_dsa:
self.delete_at_teardown.append(
add_user(self.connection, testcase_id, 'user-5'))
self.delete_at_teardown.append(
add_group(self.connection, testcase_id, 'group-5',
self.delete_at_teardown))
self.connection.extend.novell.add_members_to_groups(
self.delete_at_teardown[0][0],
self.delete_at_teardown[1][0],
fix=True,
transaction=True)
result = self.connection.search(
self.delete_at_teardown[0][0],
'(objectclass=*)',
attributes=['securityEquals', 'groupMembership'])
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
else:
response, result = self.connection.response, self.connection.result
if response:
self.assertTrue(self.delete_at_teardown[1][0] in (
response[0]['attributes']['securityEquals']
if 'securityEquals' in response[0]['attributes'] else []))
self.assertTrue(self.delete_at_teardown[1][0] in (
response[0]['attributes']['groupMembership']
if 'groupMembership' in response[0]['attributes'] else []))
else:
self.assertFalse(True,
self.delete_at_teardown[1][0] + ' not found')
result = self.connection.search(
self.delete_at_teardown[1][0],
'(objectclass=*)',
attributes=['member', 'equivalentToMe'])
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
else:
response, result = self.connection.response, self.connection.result
if response:
self.assertTrue(self.delete_at_teardown[0][0] in (
response[0]['attributes']['member'] if 'member' in
response[0]['attributes'] else []))
self.assertTrue(self.delete_at_teardown[0][0] in (
response[0]['attributes']['equivalentToMe']
if 'equivalentToMe' in response[0]['attributes'] else []))
else:
self.assertFalse(True,
self.delete_at_teardown[0][0] + ' not found')
self.connection.extend.novell.remove_members_from_groups(
self.delete_at_teardown[0][0],
self.delete_at_teardown[1][0],
fix=False,
transaction=False)
result = self.connection.search(
self.delete_at_teardown[0][0],
'(objectclass=*)',
attributes=['securityEquals', 'groupMembership'])
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
else:
response, result = self.connection.response, self.connection.result
if response:
self.assertTrue(self.delete_at_teardown[1][0] not in (
response[0]['attributes']['securityEquals']
if 'securityEquals' in response[0]['attributes'] else []))
self.assertTrue(self.delete_at_teardown[1][0] not in (
response[0]['attributes']['groupMembership']
if 'groupMembership' in response[0]['attributes'] else []))
else:
self.assertFalse(True,
self.delete_at_teardown[1][0] + ' not found')
result = self.connection.search(
self.delete_at_teardown[1][0],
'(objectclass=*)',
attributes=['member', 'equivalentToMe'])
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
else:
response, result = self.connection.response, self.connection.result
if response:
self.assertTrue(self.delete_at_teardown[0][0] not in (
response[0]['attributes']['member'] if 'member' in
response[0]['attributes'] else []))
self.assertTrue(self.delete_at_teardown[0][0] not in (
response[0]['attributes']['equivalentToMe']
if 'equivalentToMe' in response[0]['attributes'] else []))
else:
self.assertFalse(True,
self.delete_at_teardown[0][0] + ' not found')
def test_search_simple_paged(self):
if not self.connection.strategy.pooled and not self.connection.strategy.no_real_dsa:
self.delete_at_teardown.append(
add_user(self.connection,
testcase_id,
'sea-5',
attributes={'givenName': 'givenname-3'}))
self.delete_at_teardown.append(
add_user(self.connection,
testcase_id,
'sea-6',
attributes={'givenName': 'givenname-4'}))
self.delete_at_teardown.append(
add_user(self.connection,
testcase_id,
'sea-7',
attributes={'givenName': 'givenname-5'}))
self.delete_at_teardown.append(
add_user(self.connection,
testcase_id,
'sea-8',
attributes={'givenName': 'givenname-6'}))
self.delete_at_teardown.append(
add_user(self.connection,
testcase_id,
'sea-9',
attributes={'givenName': 'givenname-7'}))
self.delete_at_teardown.append(
add_user(self.connection,
testcase_id,
'sea-10',
attributes={'givenName': 'givenname-8'}))
self.delete_at_teardown.append(
add_user(self.connection,
testcase_id,
'sea-11',
attributes={'givenName': 'givenname-9'}))
paged_size = 4
total_entries = 0
status, result, response, request = get_response_values(
self.connection.search(
search_base=test_base,
search_filter='(' + test_name_attr + '=' + testcase_id +
'*)',
search_scope=SUBTREE,
attributes=[test_name_attr, 'givenName'],
paged_size=paged_size), self.connection)
self.assertEqual(result['description'], 'success')
self.assertEqual(len(response), paged_size)
total_entries += len(response)
cookie = result['controls']['1.2.840.113556.1.4.319']['value'][
'cookie']
while cookie:
status, result, response, request = get_response_values(
self.connection.search(
search_base=test_base,
search_filter='(' + test_name_attr + '=' +
testcase_id + '*)',
search_scope=SUBTREE,
attributes=[test_name_attr, 'givenName'],
paged_size=paged_size,
paged_cookie=cookie), self.connection)
self.assertEqual(result['description'], 'success')
total_entries += len(response)
self.assertTrue(len(response) <= paged_size)
cookie = result['controls']['1.2.840.113556.1.4.319']['value'][
'cookie']
self.assertEqual(total_entries, 11)
def setUp(self):
global testcase_id
testcase_id = random_id()
self.connection = get_connection()
self.delete_at_teardown = []
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'modify-1', attributes={'givenName': 'givenname-1'}))
def setUp(self):
global testcase_id
testcase_id = random_id()
self.connection = get_connection(check_names=True)
self.delete_at_teardown = []
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'delete-1'))
def test_valid_object_class_add(self):
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'chk-3', attributes={'objectClass': ['inetOrgPerson', 'Person']}))
self.assertEqual(self.delete_at_teardown[0][1]['description'], 'success')
def setUp(self):
global testcase_id
testcase_id = random_id()
self.connection = get_connection(check_names=True)
self.delete_at_teardown = []
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'compare-1', attributes={'givenName': 'compare'}))
def test_search_simple_paged(self):
if not self.connection.strategy.pooled:
self.delete_at_teardown.append(
add_user(self.connection,
testcase_id,
'sea-3',
attributes={'givenName': 'givenname-3'}))
self.delete_at_teardown.append(
add_user(self.connection,
testcase_id,
'sea-4',
attributes={'givenName': 'givenname-4'}))
self.delete_at_teardown.append(
add_user(self.connection,
testcase_id,
'sea-5',
attributes={'givenName': 'givenname-5'}))
self.delete_at_teardown.append(
add_user(self.connection,
testcase_id,
'sea-6',
attributes={'givenName': 'givenname-6'}))
self.delete_at_teardown.append(
add_user(self.connection,
testcase_id,
'sea-7',
attributes={'givenName': 'givenname-7'}))
self.delete_at_teardown.append(
add_user(self.connection,
testcase_id,
'sea-8',
attributes={'givenName': 'givenname-8'}))
self.delete_at_teardown.append(
add_user(self.connection,
testcase_id,
'sea-9',
attributes={'givenName': 'givenname-9'}))
paged_size = 4
total_entries = 0
result = self.connection.search(
search_base=test_base,
search_filter='(' + test_name_attr + '=' + testcase_id + '*)',
search_scope=SUBTREE,
attributes=[test_name_attr, 'givenName'],
paged_size=paged_size)
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
entries = self.connection._get_entries(response)
else:
result = self.connection.result
entries = self.connection.entries
self.assertEqual(result['description'], 'success')
self.assertEqual(len(entries), paged_size)
total_entries += len(entries)
cookie = result['controls']['1.2.840.113556.1.4.319']['value'][
'cookie']
while cookie:
result = self.connection.search(
search_base=test_base,
search_filter='(' + test_name_attr + '=' + testcase_id +
'*)',
search_scope=SUBTREE,
attributes=[test_name_attr, 'givenName'],
paged_size=paged_size,
paged_cookie=cookie)
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
entries = self.connection._get_entries(response)
else:
result = self.connection.result
entries = self.connection.entries
self.assertEqual(result['description'], 'success')
total_entries += len(entries)
self.assertTrue(len(entries) <= paged_size)
cookie = result['controls']['1.2.840.113556.1.4.319']['value'][
'cookie']
self.assertEqual(total_entries, 9)
def setUp(self):
global testcase_id
testcase_id = random_id()
self.connection = get_connection()
self.delete_at_teardown = []
if test_server_type == 'EDIR':
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'sea-1', attributes={'givenName': 'givenname-1', test_int_attr: 0}))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'sea-2', attributes={'givenName': 'givenname-2', test_int_attr: 0}))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, u'sea-3-\u2122', attributes={'givenName': 'givenname-3', test_int_attr: 0})) # TRADE-MARK SIGN
self.delete_at_teardown.append(add_user(self.connection, testcase_id, u'sea-4-�����', attributes={'givenName': 'givenname-4', test_int_attr: 0}))
elif test_server_type == 'AD':
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'sea-1', attributes={'givenName': 'givenname-1'}))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'sea-2', attributes={'givenName': 'givenname-2'}))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, u'sea-3-\u2122', attributes={'givenName': 'givenname-3'})) # TRADE-MARK SIGN
self.delete_at_teardown.append(add_user(self.connection, testcase_id, u'sea-4-�����', attributes={'givenName': 'givenname-4'}))
else:
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'sea-1', attributes={'givenName': 'givenname-1'}))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'sea-2', attributes={'givenName': 'givenname-2'}))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, u'sea-3-\u2122', attributes={'givenName': 'givenname-3'})) # TRADE-MARK SIGN
self.delete_at_teardown.append(add_user(self.connection, testcase_id, u'sea-4-�����', attributes={'givenName': 'givenname-4', test_int_attr: 0}))
def test_remove_members_from_groups_transactional(self):
if test_server_type == 'EDIR' and not self.connection.strategy.pooled and not self.connection.strategy.no_real_dsa:
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'user-6'))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'user-7'))
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'user-8'))
self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'group-6', self.delete_at_teardown)) # this group has members but other attributes are not set
self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'group-7'))
self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'group-8'))
self.connection.extend.novell.add_members_to_groups([self.delete_at_teardown[0][0],
self.delete_at_teardown[1][0],
self.delete_at_teardown[2][0]],
[self.delete_at_teardown[3][0],
self.delete_at_teardown[4][0],
self.delete_at_teardown[5][0]],
fix=True,
transaction=True
)
for i in range(0, 2):
status, result, response, request = get_response_values(self.connection.search(self.delete_at_teardown[i][0], '(objectclass=*)', attributes=['securityEquals', 'groupMembership']), self.connection)
if response:
for j in range(3, 5):
self.assertTrue(self.delete_at_teardown[j][0] in (response[0]['attributes']['securityEquals'] if 'securityEquals' in response[0]['attributes'] else []))
self.assertTrue(self.delete_at_teardown[j][0] in (response[0]['attributes']['groupMembership'] if 'groupMembership' in response[0]['attributes'] else []))
else:
self.assertFalse(True, self.delete_at_teardown[i][0] + ' not found')
for j in range(3, 5):
status, result, response, request = get_response_values(self.connection.search(self.delete_at_teardown[j][0], '(objectclass=*)', attributes=['member', 'equivalentToMe']), self.connection)
if response:
for i in range(0, 2):
self.assertTrue(self.delete_at_teardown[i][0] in (response[0]['attributes']['member'] if 'member' in response[0]['attributes'] else []))
self.assertTrue(self.delete_at_teardown[i][0] in (response[0]['attributes']['equivalentToMe'] if 'equivalentToMe' in response[0]['attributes'] else []))
else:
self.assertFalse(True, self.delete_at_teardown[j][0] + ' not found')
self.connection.extend.novell.remove_members_from_groups([self.delete_at_teardown[0][0],
self.delete_at_teardown[1][0],
self.delete_at_teardown[2][0]],
[self.delete_at_teardown[3][0],
self.delete_at_teardown[4][0],
self.delete_at_teardown[5][0]],
fix=True,
transaction=False
)
for i in range(0, 2):
status, result, response, request = get_response_values(self.connection.search(self.delete_at_teardown[i][0], '(objectclass=*)', attributes=['securityEquals', 'groupMembership']), self.connection)
if response:
for j in range(3, 5):
self.assertTrue(self.delete_at_teardown[j][0] not in (response[0]['attributes']['securityEquals'] if 'securityEquals' in response[0]['attributes'] else []))
self.assertTrue(self.delete_at_teardown[j][0] not in (response[0]['attributes']['groupMembership'] if 'groupMembership' in response[0]['attributes'] else []))
else:
self.assertFalse(True, self.delete_at_teardown[i][0] + ' not found')
for j in range(3, 5):
status, result, response, request = get_response_values(self.connection.search(self.delete_at_teardown[j][0], '(objectclass=*)', attributes=['member', 'equivalentToMe']), self.connection)
if response:
for i in range(0, 2):
self.assertTrue(self.delete_at_teardown[i][0] not in (response[0]['attributes']['member'] if 'member' in response[0]['attributes'] else []))
self.assertTrue(self.delete_at_teardown[i][0] not in (response[0]['attributes']['equivalentToMe'] if 'equivalentToMe' in response[0]['attributes'] else []))
else:
self.assertFalse(True, self.delete_at_teardown[j][0] + ' not found')
def test_remove_member_from_group(self):
if test_server_type == 'EDIR' and not self.connection.strategy.pooled and not self.connection.strategy.no_real_dsa:
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'user-1'))
self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'group-1'))
self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'group-1b', [self.delete_at_teardown[0]]))
self.connection.extend.novell.add_members_to_groups(self.delete_at_teardown[0][0],
[self.delete_at_teardown[1][0],
self.delete_at_teardown[2][0]],
fix=True,
transaction=False)
# verifies user in group-1
status, result, response, request = get_response_values(self.connection.search(self.delete_at_teardown[0][0], '(objectclass=*)', attributes=['securityEquals', 'groupMembership']), self.connection)
if response:
self.assertTrue(self.delete_at_teardown[1][0] in (response[0]['attributes']['securityEquals'] if 'securityEquals' in response[0]['attributes'] else []))
self.assertTrue(self.delete_at_teardown[1][0] in (response[0]['attributes']['groupMembership'] if 'groupMembership' in response[0]['attributes'] else []))
else:
self.assertFalse(True, self.delete_at_teardown[1][0] + ' not found')
status, result, response, request = get_response_values(self.connection.search(self.delete_at_teardown[1][0], '(objectclass=*)', attributes=['member', 'equivalentToMe']), self.connection)
if response:
self.assertTrue(self.delete_at_teardown[0][0] in (response[0]['attributes']['member'] if 'member' in response[0]['attributes'] else []))
self.assertTrue(self.delete_at_teardown[0][0] in (response[0]['attributes']['equivalentToMe'] if 'equivalentToMe' in response[0]['attributes'] else []))
else:
self.assertFalse(True, self.delete_at_teardown[0][0] + ' not found')
# verifies user in group-1b
status, result, response, request = get_response_values(self.connection.search(self.delete_at_teardown[0][0], '(objectclass=*)', attributes=['securityEquals', 'groupMembership']), self.connection)
if response:
self.assertTrue(self.delete_at_teardown[2][0] in (response[0]['attributes']['securityEquals'] if 'securityEquals' in response[0]['attributes'] else []))
self.assertTrue(self.delete_at_teardown[2][0] in (response[0]['attributes']['groupMembership'] if 'groupMembership' in response[0]['attributes'] else []))
else:
self.assertFalse(True, self.delete_at_teardown[2][0] + ' not found')
status, result, response, request = get_response_values(self.connection.search(self.delete_at_teardown[2][0], '(objectclass=*)', attributes=['member', 'equivalentToMe']), self.connection)
if response:
self.assertTrue(self.delete_at_teardown[0][0] in (response[0]['attributes']['member'] if 'member' in response[0]['attributes'] else []))
self.assertTrue(self.delete_at_teardown[0][0] in (response[0]['attributes']['equivalentToMe'] if 'equivalentToMe' in response[0]['attributes'] else []))
else:
self.assertFalse(True, self.delete_at_teardown[0][0] + ' not found')
self.connection.extend.novell.remove_members_from_groups(self.delete_at_teardown[0][0],
self.delete_at_teardown[1][0],
fix=False,
transaction=False)
# verifies users not in group-1
status, result, response, request = get_response_values(self.connection.search(self.delete_at_teardown[0][0], '(objectclass=*)', attributes=['securityEquals', 'groupMembership']), self.connection)
if response:
self.assertTrue(self.delete_at_teardown[1][0] not in (response[0]['attributes']['securityEquals'] if 'securityEquals' in response[0]['attributes'] else []))
self.assertTrue(self.delete_at_teardown[1][0] not in (response[0]['attributes']['groupMembership'] if 'groupMembership' in response[0]['attributes'] else []))
else:
self.assertFalse(True, self.delete_at_teardown[1][0] + ' not found')
status, result, response, request = get_response_values(self.connection.search(self.delete_at_teardown[1][0], '(objectclass=*)', attributes=['member', 'equivalentToMe']), self.connection)
if response:
self.assertTrue(self.delete_at_teardown[0][0] not in (response[0]['attributes']['member'] if 'member' in response[0]['attributes'] else []))
self.assertTrue(self.delete_at_teardown[0][0] not in (response[0]['attributes']['equivalentToMe'] if 'equivalentToMe' in response[0]['attributes'] else []))
else:
self.assertFalse(True, self.delete_at_teardown[0][0] + ' not found')
# verifies user still in group-1b
status, result, response, request = get_response_values(self.connection.search(self.delete_at_teardown[0][0], '(objectclass=*)', attributes=['securityEquals', 'groupMembership']), self.connection)
if response:
self.assertTrue(self.delete_at_teardown[2][0] in (response[0]['attributes']['securityEquals'] if 'securityEquals' in response[0]['attributes'] else []))
self.assertTrue(self.delete_at_teardown[2][0] in (response[0]['attributes']['groupMembership'] if 'groupMembership' in response[0]['attributes'] else []))
else:
self.assertFalse(True, self.delete_at_teardown[2][0] + ' not found')
status, result, response, request = get_response_values(self.connection.search(self.delete_at_teardown[2][0], '(objectclass=*)', attributes=['member', 'equivalentToMe']), self.connection)
if response:
self.assertTrue(self.delete_at_teardown[0][0] in (response[0]['attributes']['member'] if 'member' in response[0]['attributes'] else []))
self.assertTrue(self.delete_at_teardown[0][0] in (response[0]['attributes']['equivalentToMe'] if 'equivalentToMe' in response[0]['attributes'] else []))
else:
self.assertFalse(True, self.delete_at_teardown[0][0] + ' not found')
def test_add_members_to_groups(self):
if test_server_type == 'EDIR' and not self.connection.strategy.pooled and not self.connection.strategy.no_real_dsa:
self.delete_at_teardown.append(
add_user(self.connection, testcase_id, 'user-2'))
self.delete_at_teardown.append(
add_user(self.connection, testcase_id, 'user-3'))
self.delete_at_teardown.append(
add_user(self.connection, testcase_id, 'user-4'))
self.delete_at_teardown.append(
add_group(self.connection, testcase_id, 'group-2',
self.delete_at_teardown))
self.delete_at_teardown.append(
add_group(self.connection, testcase_id, 'group-3'))
self.delete_at_teardown.append(
add_group(self.connection, testcase_id, 'group-4'))
self.connection.extend.novell.add_members_to_groups(
[
self.delete_at_teardown[0][0],
self.delete_at_teardown[1][0],
self.delete_at_teardown[2][0]
], [
self.delete_at_teardown[3][0],
self.delete_at_teardown[4][0],
self.delete_at_teardown[5][0]
],
fix=True,
transaction=False)
for i in range(0, 2):
result = self.connection.search(
self.delete_at_teardown[i][0],
'(objectclass=*)',
attributes=['securityEquals', 'groupMembership'])
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
else:
response, result = self.connection.response, self.connection.result
if response:
for j in range(3, 5):
self.assertTrue(self.delete_at_teardown[j][0] in (
response[0]['attributes']['securityEquals']
if 'securityEquals' in
response[0]['attributes'] else []))
self.assertTrue(self.delete_at_teardown[j][0] in (
response[0]['attributes']['groupMembership']
if 'groupMembership' in
response[0]['attributes'] else []))
else:
self.assertFalse(
True, self.delete_at_teardown[i][0] + ' not found')
for j in range(3, 5):
result = self.connection.search(
self.delete_at_teardown[j][0],
'(objectclass=*)',
attributes=['member', 'equivalentToMe'])
if not self.connection.strategy.sync:
response, result = self.connection.get_response(result)
else:
response, result = self.connection.response, self.connection.result
if response:
for i in range(0, 2):
self.assertTrue(self.delete_at_teardown[i][0] in (
response[0]['attributes']['member'] if 'member' in
response[0]['attributes'] else []))
self.assertTrue(self.delete_at_teardown[i][0] in (
response[0]['attributes']['equivalentToMe']
if 'equivalentToMe' in
response[0]['attributes'] else []))
else:
self.assertFalse(
True, self.delete_at_teardown[j][0] + ' not found')
def test_dir_sync(self):
if False: # takes a long long time to complete
# if test_server_type == 'AD':
sync = self.connection.extend.microsoft.dir_sync(
test_root_partition, attributes=['*'])
# read all previous changes
while sync.more_results:
print('PREV', len(sync.loop()))
# add a new object and verify the sync
dn, _ = add_user(self.connection,
testcase_id,
'to-be-deleted-1',
attributes={'givenName': 'to-be-deleted-1'})
sleep(1)
response = sync.loop()
print('ADD OBJ', len(response), response[0]['attributes'])
found = False
for entry in response:
if entry[
'type'] == 'searchResEntry' and testcase_id + 'to-be-deleted-1' in entry[
'dn']:
found = True
break
self.assertTrue(found)
# modify-add an attribute and verify the sync
result = self.connection.modify(dn, {
'businessCategory': (MODIFY_ADD, ['businessCategory-1-added'])
})
if not self.connection.strategy.sync:
_, result = self.connection.get_response(result)
else:
result = self.connection.result
self.assertEqual(result['description'], 'success')
sleep(1)
response = sync.loop()
print('MOD-ADD ATTR', len(response), response[0]['attributes'])
found = False
for entry in response:
if entry[
'type'] == 'searchResEntry' and testcase_id + 'to-be-deleted-1' in entry[
'dn']:
found = True
break
self.assertTrue(found)
# modify-replace an attribute and verify the sync
result = self.connection.modify(
dn, {
'businessCategory':
(MODIFY_REPLACE, ['businessCategory-1-replaced']),
'sn': (MODIFY_REPLACE, ['sn-replaced'])
})
if not self.connection.strategy.sync:
_, result = self.connection.get_response(result)
else:
result = self.connection.result
self.assertEqual(result['description'], 'success')
sleep(1)
response = sync.loop()
print('MOD-REPLACE ATTR', len(response), response[0]['attributes'])
found = False
for entry in response:
if entry[
'type'] == 'searchResEntry' and testcase_id + 'to-be-deleted-1' in entry[
'dn']:
found = True
break
self.assertTrue(found)
# modify-delete an attribute and verify the sync
# result = self.connection.modify(dn, {'businessCategory': (MODIFY_ADD, ['businessCategory-2-added', 'businessCategory-3-added'])})
# if not self.connection.strategy.sync:
# _, result = self.connection.get_response(result)
# else:
# result = self.connection.result
# self.assertEqual(result['description'], 'success')
result = self.connection.modify(
dn, {
'businessCategory':
(MODIFY_DELETE, ['businessCategory-1-replaced'])
})
if not self.connection.strategy.sync:
_, result = self.connection.get_response(result)
else:
result = self.connection.result
self.assertEqual(result['description'], 'success')
sleep(1)
response = sync.loop()
print('MOD-DEL ATTR', len(response), response[0]['attributes'])
found = False
for entry in response:
if entry[
'type'] == 'searchResEntry' and testcase_id + 'to-be-deleted-1' in entry[
'dn']:
found = True
break
self.assertTrue(found)
# delete object and verify the sync
self.connection.delete(dn)
sleep(1)
response = sync.loop()
print('DEL OBJ', len(response), response[0]['attributes'])
found = False
for entry in response:
if entry[
'type'] == 'searchResEntry' and testcase_id + 'to-be-deleted-1' in entry[
'dn']:
found = True
break
self.assertTrue(found)
def test_valid_attribute(self):
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'chk-2', attributes={'givenName': 'given-name-2'}))
status, result, response, request = get_response_values(self.connection.search(search_base=test_base, search_filter='(' + test_name_attr + '=' + testcase_id + 'chk-2)', attributes=[test_name_attr, 'givenName']), self.connection)
self.assertEqual(result['description'], 'success')
self.assertEqual(len(response), 1)
def test_paged_search_accumulator_with_schema_single_entry(self):
self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'mat-1'))
r = Reader(self.connection, 'inetorgperson', test_base, 'cn:=' + testcase_id + 'mat-*')
entries = r.search_paged(2, True, generator=False, attributes=['cn'])
self.assertEqual(len(entries), 1)
