From d73b14a1c877982bf23b9261facd82caf50d32f0 Mon Sep 17 00:00:00 2001 From: Anuj Borah Date: May 11 2020 10:16:25 +0000 Subject: Issue:CI test - automember_plugin (Long Duration test) CI test - automember_plugin (Long Duration test) Relates: https://pagure.io/389-ds-base/issue/48055 Author: aborah Reviewed by: Viktor Ashirov --- diff --git a/dirsrvtests/tests/longduration/automembers_long_test.py b/dirsrvtests/tests/longduration/automembers_long_test.py new file mode 100644 index 0000000..c8b4fba --- /dev/null +++ b/dirsrvtests/tests/longduration/automembers_long_test.py @@ -0,0 +1,728 @@ +# --- BEGIN COPYRIGHT BLOCK --- +# Copyright (C) 2019 Red Hat, Inc. +# All rights reserved. +# +# License: GPL (version 3 or any later version). +# See LICENSE for details. +# --- END COPYRIGHT BLOCK --- + +""" +Will do stress testing of automember plugin +""" + +import os +import pytest + +from lib389.tasks import DEFAULT_SUFFIX +from lib389.topologies import topology_m4 as topo_m4 +from lib389.idm.nscontainer import nsContainers, nsContainer +from lib389.idm.organizationalunit import OrganizationalUnits +from lib389.idm.domain import Domain +from lib389.idm.posixgroup import PosixGroups +from lib389.plugins import AutoMembershipPlugin, AutoMembershipDefinitions, \ + MemberOfPlugin, AutoMembershipRegexRules +from lib389.backend import Backends +from lib389.config import Config +from lib389.replica import ReplicationManager +from lib389.tasks import AutomemberRebuildMembershipTask +from lib389.idm.group import Groups, Group, nsAdminGroups, nsAdminGroup + + +SUBSUFFIX = f'dc=SubSuffix,{DEFAULT_SUFFIX}' +REPMANDN = "cn=ReplManager" +REPMANSFX = "dc=replmangr,dc=com" +CACHE_SIZE = '-1' +CACHEMEM_SIZE = '10485760' + + +pytestmark = pytest.mark.tier3 + + +@pytest.fixture(scope="module") +def _create_entries(topo_m4): + """ + Will act as module .Will set up required user/entries for the test cases. + """ + for instance in [topo_m4.ms['master1'], topo_m4.ms['master2'], + topo_m4.ms['master3'], topo_m4.ms['master4']]: + assert instance.status() + + for org in ['autouserGroups', 'Employees', 'TaskEmployees']: + OrganizationalUnits(topo_m4.ms['master1'], DEFAULT_SUFFIX).create(properties={'ou': org}) + + Backends(topo_m4.ms['master1']).create(properties={ + 'cn': 'SubAutoMembers', + 'nsslapd-suffix': SUBSUFFIX, + 'nsslapd-CACHE_SIZE': CACHE_SIZE, + 'nsslapd-CACHEMEM_SIZE': CACHEMEM_SIZE + }) + + Domain(topo_m4.ms['master1'], SUBSUFFIX).create(properties={ + 'dc': SUBSUFFIX.split('=')[1].split(',')[0], + 'aci': [ + f'(targetattr="userPassword")(version 3.0;aci "Replication Manager Access";' + f'allow (write,compare) userdn="ldap:///{REPMANDN},cn=config";)', + f'(target ="ldap:///{SUBSUFFIX}")(targetattr !="cn||sn||uid")(version 3.0;' + f'acl "Group Permission";allow (write)(groupdn = "ldap:///cn=GroupMgr,{SUBSUFFIX}");)', + f'(target ="ldap:///{SUBSUFFIX}")(targetattr !="userPassword")(version 3.0;' + f'acl "Anonym-read access"; allow (read,search,compare) (userdn="ldap:///anyone");)'] + }) + + for suff, grp in [(DEFAULT_SUFFIX, 'SubDef1'), + (DEFAULT_SUFFIX, 'SubDef2'), + (DEFAULT_SUFFIX, 'SubDef3'), + (DEFAULT_SUFFIX, 'SubDef4'), + (DEFAULT_SUFFIX, 'SubDef5'), + (DEFAULT_SUFFIX, 'Employees'), + (DEFAULT_SUFFIX, 'NewEmployees'), + (DEFAULT_SUFFIX, 'testuserGroups'), + (SUBSUFFIX, 'subsuffGroups'), + (SUBSUFFIX, 'Employees'), + (DEFAULT_SUFFIX, 'autoMembersPlugin'), + (DEFAULT_SUFFIX, 'replsubGroups'), + ("cn=replsubGroups,{}".format(DEFAULT_SUFFIX), 'Managers'), + ("cn=replsubGroups,{}".format(DEFAULT_SUFFIX), 'Contractors'), + ("cn=replsubGroups,{}".format(DEFAULT_SUFFIX), 'Interns'), + ("cn=replsubGroups,{}".format(DEFAULT_SUFFIX), 'Visitors'), + ("ou=autouserGroups,{}".format(DEFAULT_SUFFIX), 'SuffDef1'), + ("ou=autouserGroups,{}".format(DEFAULT_SUFFIX), 'SuffDef2'), + ("ou=autouserGroups,{}".format(DEFAULT_SUFFIX), 'SuffDef3'), + ("ou=autouserGroups,{}".format(DEFAULT_SUFFIX), 'SuffDef4'), + ("ou=autouserGroups,{}".format(DEFAULT_SUFFIX), 'SuffDef5'), + ("ou=autouserGroups,{}".format(DEFAULT_SUFFIX), 'Contractors'), + ("ou=autouserGroups,{}".format(DEFAULT_SUFFIX), 'Managers'), + ("CN=testuserGroups,{}".format(DEFAULT_SUFFIX), 'TestDef1'), + ("CN=testuserGroups,{}".format(DEFAULT_SUFFIX), 'TestDef2'), + ("CN=testuserGroups,{}".format(DEFAULT_SUFFIX), 'TestDef3'), + ("CN=testuserGroups,{}".format(DEFAULT_SUFFIX), 'TestDef4'), + ("CN=testuserGroups,{}".format(DEFAULT_SUFFIX), 'TestDef5')]: + Groups(topo_m4.ms['master1'], suff, rdn=None).create(properties={'cn': grp}) + + for suff, grp, gid in [(SUBSUFFIX, 'SubDef1', '111'), + (SUBSUFFIX, 'SubDef2', '222'), + (SUBSUFFIX, 'SubDef3', '333'), + (SUBSUFFIX, 'SubDef4', '444'), + (SUBSUFFIX, 'SubDef5', '555'), + ('cn=subsuffGroups,{}'.format(SUBSUFFIX), 'Managers', '666'), + ('cn=subsuffGroups,{}'.format(SUBSUFFIX), 'Contractors', '999')]: + PosixGroups(topo_m4.ms['master1'], suff, rdn=None).create(properties={ + 'cn': grp, + 'gidNumber': gid}) + + for master in [topo_m4.ms['master1'], topo_m4.ms['master2'], + topo_m4.ms['master3'], topo_m4.ms['master4']]: + AutoMembershipPlugin(master).add("nsslapd-pluginConfigArea", + "cn=autoMembersPlugin,{}".format(DEFAULT_SUFFIX)) + MemberOfPlugin(master).enable() + + automembers = AutoMembershipDefinitions(topo_m4.ms['master1'], + f'cn=autoMembersPlugin,{DEFAULT_SUFFIX}') + automember1 = automembers.create(properties={ + 'cn': 'replsubGroups', + 'autoMemberScope': f'ou=Employees,{DEFAULT_SUFFIX}', + 'autoMemberFilter': "objectclass=posixAccount", + 'autoMemberDefaultGroup': [f'cn=SubDef1,{DEFAULT_SUFFIX}', + f'cn=SubDef2,{DEFAULT_SUFFIX}', + f'cn=SubDef3,{DEFAULT_SUFFIX}', + f'cn=SubDef4,{DEFAULT_SUFFIX}', + f'cn=SubDef5,{DEFAULT_SUFFIX}'], + 'autoMemberGroupingAttr': 'member:dn' + }) + + automembers = AutoMembershipRegexRules(topo_m4.ms['master1'], automember1.dn) + automembers.create(properties={ + 'cn': 'Managers', + 'description': f'Group placement for Managers', + 'autoMemberTargetGroup': [f'cn=Managers,cn=replsubGroups,{DEFAULT_SUFFIX}'], + 'autoMemberInclusiveRegex': ['uidNumber=^5..5$', 'gidNumber=^[1-4]..3$', + 'nsAdminGroupName=^Manager$|^Supervisor$'], + "autoMemberExclusiveRegex": ['uidNumber=^999$', + 'gidNumber=^[6-8].0$', + 'nsAdminGroupName=^Junior$'], + }) + automembers.create(properties={ + 'cn': 'Contractors', + 'description': f'Group placement for Contractors', + 'autoMemberTargetGroup': [f'cn=Contractors,cn=replsubGroups,{DEFAULT_SUFFIX}'], + 'autoMemberInclusiveRegex': ['uidNumber=^8..5$', + 'gidNumber=^[5-9]..3$', + 'nsAdminGroupName=^Contract|^Temporary$'], + "autoMemberExclusiveRegex": ['uidNumber=^[1,3,8]99$', + 'gidNumber=^[2-4]00$', + 'nsAdminGroupName=^Employee$'], + }) + automembers.create(properties={ + 'cn': 'Interns', + 'description': f'Group placement for Interns', + 'autoMemberTargetGroup': [f'cn=Interns,cn=replsubGroups,{DEFAULT_SUFFIX}'], + 'autoMemberInclusiveRegex': ['uidNumber=^1..6$', + 'gidNumber=^[1-9]..3$', + 'nsAdminGroupName=^Interns$|^Trainees$'], + "autoMemberExclusiveRegex": ['uidNumber=^[1-9]99$', + 'gidNumber=^[1-9]00$', + 'nsAdminGroupName=^Students$'],}) + automembers.create(properties={ + 'cn': 'Visitors', + 'description': f'Group placement for Visitors', + 'autoMemberTargetGroup': [f'cn=Visitors,cn=replsubGroups,{DEFAULT_SUFFIX}'], + 'autoMemberInclusiveRegex': ['uidNumber=^1..6$', + 'gidNumber=^[1-5]6.3$', + 'nsAdminGroupName=^Visitors$'], + "autoMemberExclusiveRegex": ['uidNumber=^[7-9]99$', + 'gidNumber=^[7-9]00$', + 'nsAdminGroupName=^Inter'], + }) + for instance in [topo_m4.ms['master1'], topo_m4.ms['master2'], + topo_m4.ms['master3'], topo_m4.ms['master4']]: + instance.restart() + + +def delete_users_and_wait(topo_m4, automem_scope): + """ + Deletes entries after test and waits for replication. + """ + for user in nsAdminGroups(topo_m4.ms['master1'], automem_scope, rdn=None).list(): + user.delete() + for master in [topo_m4.ms['master2'], topo_m4.ms['master3'], topo_m4.ms['master4']]: + ReplicationManager(DEFAULT_SUFFIX).wait_for_replication(topo_m4.ms['master1'], + master, timeout=30000) + + +def create_entry(topo_m4, user_id, suffix, uid_no, gid_no, role_usr): + """ + Will create entries with nsAdminGroup objectclass + """ + user = nsAdminGroups(topo_m4.ms['master1'], suffix, rdn=None).create(properties={ + 'cn': user_id, + 'sn': user_id, + 'uid': user_id, + 'homeDirectory': '/home/{}'.format(user_id), + 'loginShell': '/bin/bash', + 'uidNumber': uid_no, + 'gidNumber': gid_no, + 'objectclass': ['top', 'person', 'posixaccount', 'inetuser', + 'nsMemberOf', 'nsAccount', 'nsAdminGroup'], + 'nsAdminGroupName': role_usr, + 'seeAlso': 'uid={},{}'.format(user_id, suffix), + 'entrydn': 'uid={},{}'.format(user_id, suffix) + }) + return user + + +def test_adding_300_user(topo_m4, _create_entries): + """ + Adding 300 user entries matching the inclusive regex rules for + all targetted groups at M1 and checking the same created in M2 & M3 + :id: fcd867bc-be57-11e9-9842-8c16451d917b + :setup: Instance with 4 masters + :steps: + 1. Add 300 user entries matching the inclusive regex rules at topo_m4.ms['master1'] + 2. Check the same created in rest masters + :expected results: + 1. Pass + 2. Pass + """ + user_rdn = "long01usr" + automem_scope = "ou=Employees,{}".format(DEFAULT_SUFFIX) + grp_container = "cn=replsubGroups,{}".format(DEFAULT_SUFFIX) + default_group1 = "cn=SubDef1,{}".format(DEFAULT_SUFFIX) + default_group2 = "cn=SubDef2,{}".format(DEFAULT_SUFFIX) + # Adding BulkUsers + for number in range(300): + create_entry(topo_m4, f'{user_rdn}{number}', automem_scope, '5795', '5693', 'Contractor') + try: + # Check to sync the entries + for master in [topo_m4.ms['master2'], topo_m4.ms['master3'], topo_m4.ms['master4']]: + ReplicationManager(DEFAULT_SUFFIX).wait_for_replication(topo_m4.ms['master1'], + master, timeout=30000) + for instance, grp in [(topo_m4.ms['master2'], 'Managers'), + (topo_m4.ms['master3'], 'Contractors'), + (topo_m4.ms['master4'], 'Interns')]: + assert len(nsAdminGroup( + instance, f'cn={grp},{grp_container}').get_attr_vals_utf8('member')) == 300 + for grp in [default_group1, default_group2]: + assert not Group(topo_m4.ms['master4'], grp).get_attr_vals_utf8('member') + assert not Group(topo_m4.ms['master3'], grp).get_attr_vals_utf8('member') + + finally: + delete_users_and_wait(topo_m4, automem_scope) + + +def test_adding_1000_users(topo_m4, _create_entries): + """ + Adding 1000 users matching inclusive regex for Managers/Contractors + and exclusive regex for Interns/Visitors + :id: f641e612-be57-11e9-94e6-8c16451d917b + :setup: Instance with 4 masters + :steps: + 1. Add 1000 user entries matching the inclusive/exclusive + regex rules at topo_m4.ms['master1'] + 2. Check the same created in rest masters + :expected results: + 1. Pass + 2. Pass + """ + automem_scope = "ou=Employees,{}".format(DEFAULT_SUFFIX) + grp_container = "cn=replsubGroups,{}".format(DEFAULT_SUFFIX) + default_group1 = "cn=SubDef1,{}".format(DEFAULT_SUFFIX) + default_group2 = "cn=SubDef2,{}".format(DEFAULT_SUFFIX) + # Adding 1000 users + for number in range(1000): + create_entry(topo_m4, f'automemusrs{number}', automem_scope, '799', '5693', 'Manager') + try: + # Check to sync the entries + for master in [topo_m4.ms['master2'], topo_m4.ms['master3'], topo_m4.ms['master4']]: + ReplicationManager(DEFAULT_SUFFIX).wait_for_replication(topo_m4.ms['master1'], + master, timeout=30000) + for instance, grp in [(topo_m4.ms['master1'], 'Managers'), + (topo_m4.ms['master3'], 'Contractors')]: + assert len(nsAdminGroup( + instance, "cn={},{}".format(grp, + grp_container)).get_attr_vals_utf8('member')) == 1000 + for instance, grp in [(topo_m4.ms['master2'], 'Interns'), + (topo_m4.ms['master4'], 'Visitors')]: + assert not nsAdminGroup( + instance, "cn={},{}".format(grp, grp_container)).get_attr_vals_utf8('member') + for grp in [default_group1, default_group2]: + assert not Group(topo_m4.ms['master2'], grp).get_attr_vals_utf8('member') + assert not Group(topo_m4.ms['master3'], grp).get_attr_vals_utf8('member') + finally: + delete_users_and_wait(topo_m4, automem_scope) + + +def test_adding_3000_users(topo_m4, _create_entries): + """ + Adding 3000 users matching all inclusive regex rules and no matching exclusive regex rules + :id: ee54576e-be57-11e9-b536-8c16451d917b + :setup: Instance with 4 masters + :steps: + 1. Add 3000 user entries matching the inclusive/exclusive regex + rules at topo_m4.ms['master1'] + 2. Check the same created in rest masters + :expected results: + 1. Pass + 2. Pass + """ + automem_scope = "ou=Employees,{}".format(DEFAULT_SUFFIX) + grp_container = "cn=replsubGroups,{}".format(DEFAULT_SUFFIX) + default_group1 = "cn=SubDef3,{}".format(DEFAULT_SUFFIX) + default_group2 = "cn=SubDef5,{}".format(DEFAULT_SUFFIX) + # Adding 3000 users + for number in range(3000): + create_entry(topo_m4, f'automemusrs{number}', automem_scope, '5995', '5693', 'Manager') + try: + for master in [topo_m4.ms['master2'], topo_m4.ms['master3'], topo_m4.ms['master4']]: + ReplicationManager(DEFAULT_SUFFIX).wait_for_replication(topo_m4.ms['master1'], + master, timeout=30000) + for instance, grp in [(topo_m4.ms['master1'], 'Managers'), + (topo_m4.ms['master3'], 'Contractors'), + (topo_m4.ms['master2'], 'Interns'), + (topo_m4.ms['master4'], 'Visitors') + ]: + assert len( + nsAdminGroup(instance, + "cn={},{}".format(grp, + grp_container)).get_attr_vals_utf8('member')) == 3000 + for grp in [default_group1, default_group2]: + assert not Group(topo_m4.ms['master2'], grp).get_attr_vals_utf8('member') + assert not Group(topo_m4.ms['master3'], grp).get_attr_vals_utf8('member') + finally: + delete_users_and_wait(topo_m4, automem_scope) + + +def test_3000_users_matching_all_exclusive_regex(topo_m4, _create_entries): + """ + Adding 3000 users matching all exclusive regex rules and no matching inclusive regex rules + :id: e789331e-be57-11e9-b298-8c16451d917b + :setup: Instance with 4 masters + :steps: + 1. Add 3000 user entries matching the inclusive/exclusive regex + rules at topo_m4.ms['master1'] + 2. Check the same created in rest masters + :expected results: + 1. Pass + 2. Pass + """ + automem_scope = "ou=Employees,{}".format(DEFAULT_SUFFIX) + grp_container = "cn=replsubGroups,{}".format(DEFAULT_SUFFIX) + default_group1 = "cn=SubDef1,{}".format(DEFAULT_SUFFIX) + default_group2 = "cn=SubDef2,{}".format(DEFAULT_SUFFIX) + default_group4 = "cn=SubDef4,{}".format(DEFAULT_SUFFIX) + # Adding 3000 users + for number in range(3000): + create_entry(topo_m4, f'automemusrs{number}', automem_scope, '399', '700', 'Manager') + try: + for master in [topo_m4.ms['master2'], topo_m4.ms['master3'], topo_m4.ms['master4']]: + ReplicationManager(DEFAULT_SUFFIX).wait_for_replication(topo_m4.ms['master1'], + master, timeout=30000) + + for instance, grp in [(topo_m4.ms['master1'], default_group4), + (topo_m4.ms['master2'], default_group1), + (topo_m4.ms['master3'], default_group2), + (topo_m4.ms['master4'], default_group2)]: + assert len(nsAdminGroup(instance, grp).get_attr_vals_utf8('member')) == 3000 + for grp, instance in [('Managers', topo_m4.ms['master3']), + ('Contractors', topo_m4.ms['master2'])]: + assert not nsAdminGroup( + instance, "cn={},{}".format(grp, grp_container)).get_attr_vals_utf8('member') + + finally: + delete_users_and_wait(topo_m4, automem_scope) + + +def test_no_matching_inclusive_regex_rules(topo_m4, _create_entries): + """ + Adding 3000 users matching all exclusive regex rules and no matching inclusive regex rules + :id: e0cc0e16-be57-11e9-9c0f-8c16451d917b + :setup: Instance with 4 masters + :steps: + 1. Add 3000 user entries matching the inclusive/exclusive regex + rules at topo_m4.ms['master1'] + 2. Check the same created in rest masters + :expected results: + 1. Pass + 2. Pass + """ + automem_scope = "ou=Employees,{}".format(DEFAULT_SUFFIX) + grp_container = "cn=replsubGroups,{}".format(DEFAULT_SUFFIX) + default_group1 = "cn=SubDef1,{}".format(DEFAULT_SUFFIX) + # Adding 3000 users + for number in range(3000): + create_entry(topo_m4, f'automemusrs{number}', automem_scope, '399', '700', 'Manager') + try: + for master in [topo_m4.ms['master2'], topo_m4.ms['master3'], topo_m4.ms['master4']]: + ReplicationManager(DEFAULT_SUFFIX).wait_for_replication(topo_m4.ms['master1'], + master, timeout=30000) + for instance, grp in [(topo_m4.ms['master1'], "cn=SubDef4,{}".format(DEFAULT_SUFFIX)), + (topo_m4.ms['master2'], default_group1), + (topo_m4.ms['master3'], "cn=SubDef2,{}".format(DEFAULT_SUFFIX)), + (topo_m4.ms['master4'], "cn=SubDef3,{}".format(DEFAULT_SUFFIX))]: + assert len(nsAdminGroup(instance, grp).get_attr_vals_utf8('member')) == 3000 + for grp, instance in [('Managers', topo_m4.ms['master3']), + ('Contractors', topo_m4.ms['master2'])]: + assert not nsAdminGroup( + instance, "cn={},{}".format(grp, grp_container)).get_attr_vals_utf8('member') + finally: + delete_users_and_wait(topo_m4, automem_scope) + + +def test_adding_deleting_and_re_adding_the_same_3000(topo_m4, _create_entries): + """ + Adding, Deleting and re-adding the same 3000 users matching all + exclusive regex rules and no matching inclusive regex rules + :id: d939247c-be57-11e9-825d-8c16451d917b + :setup: Instance with 4 masters + :steps: + 1. Add 3000 user entries matching the inclusive/exclusive regex + rules at topo_m4.ms['master1'] + 2. Check the same created in rest masters + 3. Delete 3000 users + 4. Again add 3000 users + 5. Check the same created in rest masters + :expected results: + 1. Pass + 2. Pass + 3. Pass + 4. Pass + 5. Pass + """ + automem_scope = "ou=Employees,{}".format(DEFAULT_SUFFIX) + grp_container = "cn=replsubGroups,{}".format(DEFAULT_SUFFIX) + default_group1 = "cn=SubDef1,{}".format(DEFAULT_SUFFIX) + # Adding + for number in range(3000): + create_entry(topo_m4, f'automemusrs{number}', automem_scope, '399', '700', 'Manager') + try: + for master in [topo_m4.ms['master2'], topo_m4.ms['master3'], topo_m4.ms['master4']]: + ReplicationManager(DEFAULT_SUFFIX).wait_for_replication(topo_m4.ms['master1'], + master, timeout=30000) + assert len(nsAdminGroup(topo_m4.ms['master2'], + default_group1).get_attr_vals_utf8('member')) == 3000 + # Deleting + for user in nsAdminGroups(topo_m4.ms['master2'], automem_scope, rdn=None).list(): + user.delete() + for master in [topo_m4.ms['master1'], topo_m4.ms['master3'], topo_m4.ms['master4']]: + ReplicationManager(DEFAULT_SUFFIX).wait_for_replication(topo_m4.ms['master2'], + master, timeout=30000) + # Again adding + for number in range(3000): + create_entry(topo_m4, f'automemusrs{number}', automem_scope, '399', '700', 'Manager') + for master in [topo_m4.ms['master2'], topo_m4.ms['master3'], topo_m4.ms['master4']]: + ReplicationManager(DEFAULT_SUFFIX).wait_for_replication(topo_m4.ms['master1'], + master, timeout=30000) + for instance, grp in [(topo_m4.ms['master1'], "cn=SubDef4,{}".format(DEFAULT_SUFFIX)), + (topo_m4.ms['master3'], "cn=SubDef5,{}".format(DEFAULT_SUFFIX)), + (topo_m4.ms['master4'], "cn=SubDef3,{}".format(DEFAULT_SUFFIX))]: + assert len(nsAdminGroup(instance, grp).get_attr_vals_utf8('member')) == 3000 + for grp, instance in [('Interns', topo_m4.ms['master3']), + ('Contractors', topo_m4.ms['master2'])]: + assert not nsAdminGroup( + instance, "cn={},{}".format(grp, grp_container)).get_attr_vals_utf8('member') + finally: + delete_users_and_wait(topo_m4, automem_scope) + + +def test_re_adding_the_same_3000_users(topo_m4, _create_entries): + """ + Adding, Deleting and re-adding the same 3000 users matching all inclusive + regex rules and no matching exclusive regex rules + :id: d2f5f112-be57-11e9-b164-8c16451d917b + :setup: Instance with 4 masters + :steps: + 1. Add 3000 user entries matching the inclusive/exclusive regex + rules at topo_m4.ms['master1'] + 2. Check the same created in rest masters + 3. Delete 3000 users + 4. Again add 3000 users + 5. Check the same created in rest masters + :expected results: + 1. Pass + 2. Pass + 3. Pass + 4. Pass + 5. Pass + """ + automem_scope = "ou=Employees,{}".format(DEFAULT_SUFFIX) + grp_container = "cn=replsubGroups,{}".format(DEFAULT_SUFFIX) + default_group1 = "cn=SubDef3,{}".format(DEFAULT_SUFFIX) + default_group2 = "cn=SubDef5,{}".format(DEFAULT_SUFFIX) + # Adding + for number in range(3000): + create_entry(topo_m4, f'automemusrs{number}', automem_scope, '5995', '5693', 'Manager') + try: + for master in [topo_m4.ms['master1'], topo_m4.ms['master3'], topo_m4.ms['master4']]: + ReplicationManager(DEFAULT_SUFFIX).wait_for_replication(topo_m4.ms['master2'], + master, timeout=30000) + assert len(nsAdminGroup( + topo_m4.ms['master2'], + f'cn=Contractors,{grp_container}').get_attr_vals_utf8('member')) == 3000 + # Deleting + delete_users_and_wait(topo_m4, automem_scope) + + # re-adding + for number in range(3000): + create_entry(topo_m4, f'automemusrs{number}', automem_scope, '5995', '5693', 'Manager') + for master in [topo_m4.ms['master2'], topo_m4.ms['master3'], topo_m4.ms['master4']]: + ReplicationManager(DEFAULT_SUFFIX).wait_for_replication(topo_m4.ms['master1'], + master, timeout=30000) + for instance, grp in [(topo_m4.ms['master1'], "cn=Managers,{}".format(grp_container)), + (topo_m4.ms['master3'], "cn=Contractors,{}".format(grp_container)), + (topo_m4.ms['master4'], "cn=Visitors,{}".format(grp_container)), + (topo_m4.ms['master2'], "cn=Interns,{}".format(grp_container))]: + assert len(nsAdminGroup(instance, grp).get_attr_vals_utf8('member')) == 3000 + for grp, instance in [(default_group2, topo_m4.ms['master4']), + (default_group1, topo_m4.ms['master3'])]: + assert not nsAdminGroup(instance, grp).get_attr_vals_utf8('member') + finally: + delete_users_and_wait(topo_m4, automem_scope) + + +def test_users_with_different_uid_and_gid_nos(topo_m4, _create_entries): + """ + Adding, Deleting and re-adding the same 3000 users with + different uid and gid nos, with different inclusive/exclusive matching regex rules + :id: cc595a1a-be57-11e9-b053-8c16451d917b + :setup: Instance with 4 masters + :steps: + 1. Add 3000 user entries matching the inclusive/exclusive regex + rules at topo_m4.ms['master1'] + 2. Check the same created in rest masters + 3. Delete 3000 users + 4. Again add 3000 users + 5. Check the same created in rest masters + :expected results: + 1. Pass + 2. Pass + 3. Pass + 4. Pass + 5. Pass + """ + automem_scope = "ou=Employees,{}".format(DEFAULT_SUFFIX) + grp_container = "cn=replsubGroups,{}".format(DEFAULT_SUFFIX) + default_group1 = "cn=SubDef3,{}".format(DEFAULT_SUFFIX) + default_group2 = "cn=SubDef5,{}".format(DEFAULT_SUFFIX) + # Adding + for number in range(3000): + create_entry(topo_m4, f'automemusrs{number}', automem_scope, '3994', '5695', 'OnDeputation') + try: + for master in [topo_m4.ms['master2'], topo_m4.ms['master3'], topo_m4.ms['master4']]: + ReplicationManager(DEFAULT_SUFFIX).wait_for_replication(topo_m4.ms['master1'], + master, timeout=30000) + for intstance, grp in [(topo_m4.ms['master2'], default_group1), + (topo_m4.ms['master3'], default_group2)]: + assert len(nsAdminGroup(intstance, grp).get_attr_vals_utf8('member')) == 3000 + for grp, instance in [('Contractors', topo_m4.ms['master3']), + ('Managers', topo_m4.ms['master1'])]: + assert not nsAdminGroup( + instance, "cn={},{}".format(grp, grp_container)).get_attr_vals_utf8('member') + # Deleting + for user in nsAdminGroups(topo_m4.ms['master1'], automem_scope, rdn=None).list(): + user.delete() + for master in [topo_m4.ms['master2'], topo_m4.ms['master3'], topo_m4.ms['master4']]: + ReplicationManager(DEFAULT_SUFFIX).wait_for_replication(topo_m4.ms['master1'], + master, timeout=30000) + # re-adding + for number in range(3000): + create_entry(topo_m4, f'automemusrs{number}', automem_scope, + '5995', '5693', 'OnDeputation') + + for master in [topo_m4.ms['master2'], topo_m4.ms['master3'], topo_m4.ms['master4']]: + ReplicationManager(DEFAULT_SUFFIX).wait_for_replication(topo_m4.ms['master1'], + master, timeout=30000) + for grp, instance in [('Contractors', topo_m4.ms['master3']), + ('Managers', topo_m4.ms['master1']), + ('Interns', topo_m4.ms['master2']), + ('Visitors', topo_m4.ms['master4'])]: + assert len(nsAdminGroup( + instance, f'cn={grp},{grp_container}').get_attr_vals_utf8('member')) == 3000 + + for instance, grp in [(topo_m4.ms['master2'], default_group1), + (topo_m4.ms['master3'], default_group2)]: + assert not nsAdminGroup(instance, grp).get_attr_vals_utf8('member') + finally: + delete_users_and_wait(topo_m4, automem_scope) + + +def test_bulk_users_to_non_automemscope(topo_m4, _create_entries): + """ + Adding bulk users to non-automem_scope and then running modrdn + operation to change the ou to automem_scope + :id: c532dc0c-be57-11e9-bcca-8c16451d917b + :setup: Instance with 4 masters + :steps: + 1. Running modrdn operation to change the ou to automem_scope + 2. Add 3000 user entries to non-automem_scope at topo_m4.ms['master1'] + 3. Run AutomemberRebuildMembershipTask + 4. Check the same created in rest masters + :expected results: + 1. Pass + 2. Pass + 3. Pass + 4. Pass + """ + automem_scope = "cn=EmployeesNew,{}".format(DEFAULT_SUFFIX) + grp_container = "cn=replsubGroups,{}".format(DEFAULT_SUFFIX) + default_group1 = "cn=SubDef3,{}".format(DEFAULT_SUFFIX) + default_group2 = "cn=SubDef5,{}".format(DEFAULT_SUFFIX) + nsContainers(topo_m4.ms['master1'], DEFAULT_SUFFIX).create(properties={'cn': 'ChangeThisCN'}) + Group(topo_m4.ms['master1'], + f'cn=replsubGroups,cn=autoMembersPlugin,{DEFAULT_SUFFIX}').replace('autoMemberScope', + automem_scope) + for instance in [topo_m4.ms['master1'], topo_m4.ms['master2'], + topo_m4.ms['master3'], topo_m4.ms['master4']]: + instance.restart() + # Adding BulkUsers + for number in range(3000): + create_entry(topo_m4, f'automemusrs{number}', f'cn=ChangeThisCN,{DEFAULT_SUFFIX}', + '5995', '5693', 'Supervisor') + try: + for master in [topo_m4.ms['master2'], topo_m4.ms['master3'], topo_m4.ms['master4']]: + ReplicationManager(DEFAULT_SUFFIX).wait_for_replication(topo_m4.ms['master1'], + master, timeout=30000) + for instance, grp in [(topo_m4.ms['master2'], default_group1), + (topo_m4.ms['master1'], "cn=Managers,{}".format(grp_container))]: + assert not nsAdminGroup(instance, grp).get_attr_vals_utf8('member') + # Deleting BulkUsers "User_Name" Suffix "Nof_Users" + topo_m4.ms['master3'].rename_s(f"CN=ChangeThisCN,{DEFAULT_SUFFIX}", + f'cn=EmployeesNew', newsuperior=DEFAULT_SUFFIX, delold=1) + for master in [topo_m4.ms['master2'], topo_m4.ms['master3'], topo_m4.ms['master4']]: + ReplicationManager(DEFAULT_SUFFIX).wait_for_replication(topo_m4.ms['master1'], + master, timeout=30000) + AutomemberRebuildMembershipTask(topo_m4.ms['master1']).create(properties={ + 'basedn': automem_scope, + 'filter': "objectClass=posixAccount" + }) + for master in [topo_m4.ms['master2'], topo_m4.ms['master3'], topo_m4.ms['master4']]: + ReplicationManager(DEFAULT_SUFFIX).wait_for_replication(topo_m4.ms['master1'], + master, timeout=30000) + for instance, grp in [(topo_m4.ms['master1'], 'Managers'), + (topo_m4.ms['master2'], 'Interns'), + (topo_m4.ms['master3'], 'Contractors'), + (topo_m4.ms['master4'], 'Visitors')]: + assert len(nsAdminGroup( + instance, f'cn={grp},{grp_container}').get_attr_vals_utf8('member')) == 3000 + for grp, instance in [(default_group1, topo_m4.ms['master2']), + (default_group2, topo_m4.ms['master3'])]: + assert not nsAdminGroup(instance, grp).get_attr_vals_utf8('member') + finally: + delete_users_and_wait(topo_m4, automem_scope) + nsContainer(topo_m4.ms['master1'], "CN=EmployeesNew,{}".format(DEFAULT_SUFFIX)).delete() + + +def test_automemscope_and_running_modrdn(topo_m4, _create_entries): + """ + Adding bulk users to non-automem_scope and running modrdn operation + with new superior to automem_scope + :id: bf60f958-be57-11e9-945d-8c16451d917b + :setup: Instance with 4 masters + :steps: + 1. Running modrdn operation to change the ou to automem_scope + 2. Add 3000 user entries to non-automem_scope at topo_m4.ms['master1'] + 3. Run AutomemberRebuildMembershipTask + 4. Check the same created in rest masters + :expected results: + 1. Pass + 2. Pass + 3. Pass + 4. Pass + """ + user_rdn = "long09usr" + automem_scope1 = "ou=Employees,{}".format(DEFAULT_SUFFIX) + automem_scope2 = "cn=NewEmployees,{}".format(DEFAULT_SUFFIX) + grp_container = "cn=replsubGroups,{}".format(DEFAULT_SUFFIX) + default_group1 = "cn=SubDef3,{}".format(DEFAULT_SUFFIX) + default_group2 = "cn=SubDef5,{}".format(DEFAULT_SUFFIX) + OrganizationalUnits(topo_m4.ms['master1'], + DEFAULT_SUFFIX).create(properties={'ou': 'NewEmployees'}) + Group(topo_m4.ms['master1'], + f'cn=replsubGroups,cn=autoMembersPlugin,{DEFAULT_SUFFIX}').replace('autoMemberScope', + automem_scope2) + for instance in [topo_m4.ms['master1'], topo_m4.ms['master2'], + topo_m4.ms['master3'], topo_m4.ms['master4']]: + Config(instance).replace('nsslapd-errorlog-level', '73728') + instance.restart() + # Adding bulk users + for number in range(3000): + create_entry(topo_m4, f'automemusrs{number}', automem_scope1, + '3994', '5695', 'OnDeputation') + try: + for master in [topo_m4.ms['master2'], topo_m4.ms['master3'], topo_m4.ms['master4']]: + ReplicationManager(DEFAULT_SUFFIX).wait_for_replication(topo_m4.ms['master1'], + master, timeout=30000) + for grp, instance in [(default_group2, topo_m4.ms['master3']), + ("cn=Managers,{}".format(grp_container), topo_m4.ms['master1']), + ("cn=Contractors,{}".format(grp_container), topo_m4.ms['master3'])]: + assert not nsAdminGroup(instance, grp).get_attr_vals_utf8('member') + count = 0 + for user in nsAdminGroups(topo_m4.ms['master3'], automem_scope1, rdn=None).list(): + topo_m4.ms['master1'].rename_s(user.dn, + f'cn=New{user_rdn}{count}', + newsuperior=automem_scope2, delold=1) + count += 1 + for master in [topo_m4.ms['master2'], topo_m4.ms['master3'], topo_m4.ms['master4']]: + ReplicationManager(DEFAULT_SUFFIX).wait_for_replication(topo_m4.ms['master1'], + master, timeout=30000) + AutomemberRebuildMembershipTask(topo_m4.ms['master1']).create(properties={ + 'basedn': automem_scope2, + 'filter': "objectClass=posixAccount" + }) + for master in [topo_m4.ms['master2'], topo_m4.ms['master3'], topo_m4.ms['master4']]: + ReplicationManager(DEFAULT_SUFFIX).wait_for_replication(topo_m4.ms['master1'], + master, timeout=30000) + for instance, grp in [(topo_m4.ms['master3'], default_group2), + (topo_m4.ms['master3'], default_group1)]: + assert len(nsAdminGroup(instance, grp).get_attr_vals_utf8('member')) == 3000 + for instance, grp in [(topo_m4.ms['master1'], 'Managers'), + (topo_m4.ms['master3'], 'Contractors'), + (topo_m4.ms['master2'], 'Interns'), + (topo_m4.ms['master4'], 'Visitors')]: + assert not nsAdminGroup( + instance, "cn={},{}".format(grp, grp_container)).get_attr_vals_utf8('member') + finally: + for scope in [automem_scope1, automem_scope2]: + delete_users_and_wait(topo_m4, scope) + + +if __name__ == '__main__': + CURRENT_FILE = os.path.realpath(__file__) + pytest.main("-s -v %s" % CURRENT_FILE)