Debian Codegraph @

dirsrvtests/tests/suites/automember_plugin/basic_test.py

raw
1 # --- BEGIN COPYRIGHT BLOCK ---
2 # Copyright (C) 2019 Red Hat, Inc.
3 # All rights reserved.
4 #
5 # License: GPL (version 3 or any later version).
6 # See LICENSE for details.
7 # --- END COPYRIGHT BLOCK ---
8
9 """
10 Will test AutoMememer Plugin with AotoMember Task and Retro Changelog
11 """
12
13 import os
14 import pytest
15 import time
16 import re
17 from test389.topologies import topology_m1 as topo
18 from lib389.idm.organizationalunit import OrganizationalUnits
19 from lib389.idm.domain import Domain
20 from lib389.idm.posixgroup import PosixGroups
21 from lib389.plugins import AutoMembershipPlugin, AutoMembershipDefinitions, \
22 MemberOfPlugin, AutoMembershipRegexRules, AutoMembershipDefinition, RetroChangelogPlugin, \
23 ReferentialIntegrityPlugin
24 from lib389.backend import Backends
25 from lib389.config import Config
26 from lib389._constants import DEFAULT_SUFFIX
27 from lib389.idm.user import UserAccounts
28 from lib389.idm.group import Groups, Group, UniqueGroup, nsAdminGroups, nsAdminGroup
29 from lib389.tasks import Tasks, AutomemberRebuildMembershipTask, ExportTask
30 from lib389.utils import ds_is_older
31 from lib389.paths import Paths
32 import ldap
33
34 pytestmark = pytest.mark.tier1
35
36 BASE_SUFF = "dc=autoMembers,dc=com"
37 TEST_BASE = "dc=testAutoMembers,dc=com"
38 BASE_REPL = "dc=replAutoMembers,dc=com"
39 SUBSUFFIX = f'dc=SubSuffix,{BASE_SUFF}'
40 PLUGIN_AUTO = "cn=Auto Membership Plugin,cn=plugins,cn=config"
41 REPMANDN = "cn=ReplManager"
42 CACHE_SIZE = '-1'
43 CACHEMEM_SIZE = '10485760'
44 AUTO_MEM_SCOPE_TEST = f'ou=Employees,{TEST_BASE}'
45 AUTO_MEM_SCOPE_BASE = f'ou=Employees,{BASE_SUFF}'
46
47
48 def add_base_entries(topo):
49 """
50 Will create suffix
51 """
52 for suffix, backend_name in [(BASE_SUFF, 'AutoMembers'), (SUBSUFFIX, 'SubAutoMembers'),
53 (TEST_BASE, 'testAutoMembers'), (BASE_REPL, 'ReplAutoMembers'),
54 ("dc=SubSuffix,{}".format(BASE_REPL), 'ReplSubAutoMembers')]:
55 Backends(topo.ms["supplier1"]).create(properties={
56 'cn': backend_name,
57 'nsslapd-suffix': suffix,
58 'nsslapd-CACHE_SIZE': CACHE_SIZE,
59 'nsslapd-CACHEMEM_SIZE': CACHEMEM_SIZE})
60 Domain(topo.ms["supplier1"], suffix).create(properties={
61 'dc': suffix.split('=')[1].split(',')[0],
62 'aci': [
63 f'(targetattr="userPassword")(version 3.0;aci "Replication Manager '
64 f'Access";allow (write,compare) userdn="ldap:///{REPMANDN},cn=config";)',
65 f'(target ="ldap:///{suffix}")(targetattr !="cn||sn||uid") (version 3.0;'
66 f'acl "Group Permission";allow (write) '
67 f'(groupdn = "ldap:///cn=GroupMgr,{suffix}");)',
68 f'(target ="ldap:///{suffix}")(targetattr !="userPassword")(version 3.0;acl '
69 f'"Anonym-read access"; allow (read,search,compare)(userdn="ldap:///anyone");)'
70 ]
71 })
72 for suffix, ou_cn in [(BASE_SUFF, 'userGroups'),
73 (BASE_SUFF, 'Employees'),
74 (BASE_SUFF, 'TaskEmployees'),
75 (TEST_BASE, 'Employees')]:
76 OrganizationalUnits(topo.ms["supplier1"], suffix).create(properties={'ou': ou_cn})
77
78
79 def add_user(topo, user_id, suffix, uid_no, gid_no, role_usr):
80 """
81 Will create entries with nsAdminGroup objectclass
82 """
83 objectclasses = ['top', 'person', 'posixaccount', 'inetuser',
84 'nsMemberOf', 'nsAccount', 'nsAdminGroup']
85 if ds_is_older('1.4.0'):
86 objectclasses.remove('nsAccount')
87
88 user = nsAdminGroups(topo.ms["supplier1"], suffix, rdn=None).create(properties={
89 'cn': user_id,
90 'sn': user_id,
91 'uid': user_id,
92 'homeDirectory': '/home/{}'.format(user_id),
93 'loginShell': '/bin/bash',
94 'uidNumber': uid_no,
95 'gidNumber': gid_no,
96 'objectclass': objectclasses,
97 'nsAdminGroupName': role_usr,
98 'seeAlso': 'uid={},{}'.format(user_id, suffix),
99 'entrydn': 'uid={},{}'.format(user_id, suffix)
100 })
101 return user
102
103
104 def check_groups(topo, group_dn, user_dn, member):
105 """
106 Will check MEMBATTR
107 """
108 return bool(Group(topo.ms["supplier1"], group_dn).present(member, user_dn))
109
110
111 def add_group(topo, suffix, group_id):
112 """
113 Will create groups
114 """
115 Groups(topo.ms["supplier1"], suffix, rdn=None).create(properties={
116 'cn': group_id
117 })
118
119
120 def number_memberof(topo, user, number):
121 """
122 Function to check if the memberOf attribute is present.
123 """
124 return len(nsAdminGroup(topo.ms["supplier1"], user).get_attr_vals_utf8('memberOf')) == number
125
126
127 def add_group_entries(topo):
128 """
129 Will create multiple entries needed for this test script
130 """
131 for suffix, group in [(SUBSUFFIX, 'subsuffGroups'),
132 (SUBSUFFIX, 'Employees'),
133 (TEST_BASE, 'testuserGroups'),
134 ("dc=SubSuffix,{}".format(BASE_REPL), 'replsubGroups'),
135 (BASE_REPL, 'replsubGroups')]:
136 add_group(topo, suffix, group)
137 for group_cn in ['SubDef1', 'SubDef2', 'SubDef3', 'SubDef4', 'SubDef5']:
138 add_group(topo, BASE_REPL, group_cn)
139 for user in ['Managers', 'Contractors', 'Interns', 'Visitors']:
140 add_group(topo, "cn=replsubGroups,{}".format(BASE_REPL), user)
141 for ou_ou, group_cn in [("ou=userGroups,{}".format(BASE_SUFF), 'SuffDef1'),
142 ("ou=userGroups,{}".format(BASE_SUFF), 'SuffDef2'),
143 ("ou=userGroups,{}".format(BASE_SUFF), 'SuffDef3'),
144 ("ou=userGroups,{}".format(BASE_SUFF), 'SuffDef4'),
145 ("ou=userGroups,{}".format(BASE_SUFF), 'SuffDef5'),
146 ("ou=userGroups,{}".format(BASE_SUFF), 'Contractors'),
147 ("ou=userGroups,{}".format(BASE_SUFF), 'Managers'),
148 ("CN=testuserGroups,{}".format(TEST_BASE), 'TestDef1'),
149 ("CN=testuserGroups,{}".format(TEST_BASE), 'TestDef2'),
150 ("CN=testuserGroups,{}".format(TEST_BASE), 'TestDef3'),
151 ("CN=testuserGroups,{}".format(TEST_BASE), 'TestDef4'),
152 ("CN=testuserGroups,{}".format(TEST_BASE), 'TestDef5')]:
153 add_group(topo, ou_ou, group_cn)
154 for ou_ou, group_cn, grp_no in [(SUBSUFFIX, 'SubDef1', '111'),
155 (SUBSUFFIX, 'SubDef2', '222'),
156 (SUBSUFFIX, 'SubDef3', '333'),
157 (SUBSUFFIX, 'SubDef4', '444'),
158 (SUBSUFFIX, 'SubDef5', '555'),
159 ('cn=subsuffGroups,{}'.format(SUBSUFFIX),
160 'Managers', '666'),
161 ('cn=subsuffGroups,{}'.format(SUBSUFFIX),
162 'Contractors', '999')]:
163 PosixGroups(topo.ms["supplier1"], ou_ou, rdn=None).create(properties={
164 'cn': group_cn,
165 'gidNumber': grp_no
166 })
167
168
169 def add_member_attr(topo, group_dn, user_dn, member):
170 """
171 Will add members to groups
172 """
173 Group(topo.ms["supplier1"], group_dn).add(member, user_dn)
174
175
176 def change_grp_objclass(new_object, member, type_of):
177 """
178 Will change objectClass
179 """
180 try:
181 type_of.remove(member, None)
182 except ldap.NO_SUCH_ATTRIBUTE:
183 pass
184 type_of.ensure_state(properties={
185 'cn': type_of.get_attr_val_utf8('cn'),
186 'objectClass': ['top', 'nsMemberOf', new_object]
187 })
188
189
190 @pytest.fixture(scope="module")
191 def _create_all_entries(topo):
192 """
193 Fixture module that will create required entries for test cases.
194 """
195 add_base_entries(topo)
196 add_group_entries(topo)
197 auto = AutoMembershipPlugin(topo.ms["supplier1"])
198 auto.add("nsslapd-pluginConfigArea", "cn=autoMembersPlugin,{}".format(BASE_REPL))
199 MemberOfPlugin(topo.ms["supplier1"]).enable()
200 ReferentialIntegrityPlugin(topo.ms["supplier1"]).enable()
201 automembers_definitions = AutoMembershipDefinitions(topo.ms["supplier1"])
202 automembers_definitions.create(properties={
203 'cn': 'userGroups',
204 'autoMemberScope': f'ou=Employees,{BASE_SUFF}',
205 'autoMemberFilter': "objectclass=posixAccount",
206 'autoMemberDefaultGroup': [
207 f'cn=SuffDef1,ou=userGroups,{BASE_SUFF}',
208 f'cn=SuffDef2,ou=userGroups,{BASE_SUFF}',
209 f'cn=SuffDef3,ou=userGroups,{BASE_SUFF}',
210 f'cn=SuffDef4,ou=userGroups,{BASE_SUFF}',
211 f'cn=SuffDef5,ou=userGroups,{BASE_SUFF}'
212 ],
213 'autoMemberGroupingAttr': 'member:dn',
214 })
215
216 automembers_definitions.create(properties={
217 'cn': 'subsuffGroups',
218 'autoMemberScope': f'ou=Employees,{BASE_SUFF}',
219 'autoMemberFilter': "objectclass=posixAccount",
220 'autoMemberDefaultGroup': [
221 f'cn=SubDef1,dc=subSuffix,{BASE_SUFF}',
222 f'cn=SubDef2,dc=subSuffix,{BASE_SUFF}',
223 f'cn=SubDef3,dc=subSuffix,{BASE_SUFF}',
224 f'cn=SubDef4,dc=subSuffix,{BASE_SUFF}',
225 f'cn=SubDef5,dc=subSuffix,{BASE_SUFF}',
226 ],
227 'autoMemberGroupingAttr': 'memberuid:dn',
228 })
229
230 automembers_regex_usergroup = AutoMembershipRegexRules(topo.ms["supplier1"],
231 f'cn=userGroups,{auto.dn}')
232 automembers_regex_usergroup.create(properties={
233 'cn': 'Managers',
234 'description': f'Group placement for Managers',
235 'autoMemberTargetGroup': [f'cn=Managers,ou=userGroups,{BASE_SUFF}'],
236 'autoMemberInclusiveRegex': [
237 "gidNumber=^9",
238 "nsAdminGroupName=^Manager",
239 ],
240 "autoMemberExclusiveRegex": [
241 "gidNumber=^[6-8]",
242 "nsAdminGroupName=^Junior$",
243 ],
244 })
245
246 automembers_regex_usergroup.create(properties={
247 'cn': 'Contractors',
248 'description': f'Group placement for Contractors',
249 'autoMemberTargetGroup': [f'cn=Contractors,ou=userGroups,{BASE_SUFF}'],
250 'autoMemberInclusiveRegex': [
251 "gidNumber=^1",
252 "nsAdminGroupName=Contractor",
253 ],
254 "autoMemberExclusiveRegex": [
255 "gidNumber=^[2-4]",
256 "nsAdminGroupName=^Employee$",
257 ],
258 })
259
260 automembers_regex_sub = AutoMembershipRegexRules(topo.ms["supplier1"],
261 f'cn=subsuffGroups,{auto.dn}')
262 automembers_regex_sub.create(properties={
263 'cn': 'Managers',
264 'description': f'Group placement for Managers',
265 'autoMemberTargetGroup': [f'cn=Managers,cn=subsuffGroups,dc=subSuffix,{BASE_SUFF}'],
266 'autoMemberInclusiveRegex': [
267 "gidNumber=^[1-4]..3$",
268 "uidNumber=^5.5$",
269 "nsAdminGroupName=^Manager$|^Supervisor$",
270 ],
271 "autoMemberExclusiveRegex": [
272 "gidNumber=^[6-8].0$",
273 "uidNumber=^999$",
274 "nsAdminGroupName=^Junior$",
275 ],
276 })
277
278 automembers_regex_sub.create(properties={
279 'cn': 'Contractors',
280 'description': f'Group placement for Contractors',
281 'autoMemberTargetGroup': [f'cn=Contractors,cn=subsuffGroups,dc=SubSuffix,{BASE_SUFF}'],
282 'autoMemberInclusiveRegex': [
283 "gidNumber=^[5-9].3$",
284 "uidNumber=^8..5$",
285 "nsAdminGroupName=^Contract|^Temporary$",
286 ],
287 "autoMemberExclusiveRegex": [
288 "gidNumber=^[2-4]00$",
289 "uidNumber=^[1,3,8]99$",
290 "nsAdminGroupName=^Employee$",
291 ],
292 })
293 for cn_name, ou_name in [('testuserGroups', 'Employees'), ('hostGroups', 'HostEntries')]:
294 automembers_definitions.create(properties={
295 'cn': cn_name,
296 'autoMemberScope': f'ou={ou_name},dc=testautoMembers,dc=com',
297 'autoMemberFilter': "objectclass=posixAccount",
298 'autoMemberDefaultGroup': [
299 f'cn=TestDef1,cn={cn_name},dc=testautoMembers,dc=com',
300 f'cn=TestDef2,cn={cn_name},dc=testautoMembers,dc=com',
301 f'cn=TestDef3,cn={cn_name},dc=testautoMembers,dc=com',
302 f'cn=TestDef4,cn={cn_name},dc=testautoMembers,dc=com',
303 f'cn=TestDef5,cn={cn_name},dc=testautoMembers,dc=com',
304 ],
305 'autoMemberGroupingAttr': 'member:dn',
306 })
307
308 topo.ms["supplier1"].restart()
309
310
311 def test_disable_the_plug_in(topo, _create_all_entries):
312 """Plug-in and check the status
313
314 :id: 4feee76c-e7ff-11e8-836e-8c16451d917b
315 :setup: Instance with replication
316 :steps:
317 1. Disable the plug-in and check the status
318 2. Enable the plug-in and check the status
319 :expectedresults:
320 1. Should success
321 2. Should success
322 """
323 instance_auto = AutoMembershipPlugin(topo.ms["supplier1"])
324 instance_auto.disable()
325 assert not instance_auto.status()
326 instance_auto.enable()
327 assert instance_auto.status()
328
329
330 def test_custom_config_area(topo, _create_all_entries):
331 """Custom config area
332
333 :id: 4fefb8cc-e7ff-11e8-92fd-8c16451d917b
334 :setup: Instance with replication
335 :steps:
336 1. Check whether the plugin can be configured for custom config area
337 2. After adding custom config area can be removed
338 :expectedresults:
339 1. Should success
340 2. Should success
341 """
342 instance_auto = AutoMembershipPlugin(topo.ms["supplier1"])
343 instance_auto.replace("nsslapd-pluginConfigArea", DEFAULT_SUFFIX)
344 assert instance_auto.get_attr_val_utf8("nsslapd-pluginConfigArea")
345 instance_auto.remove("nsslapd-pluginConfigArea", DEFAULT_SUFFIX)
346 assert not instance_auto.get_attr_val_utf8("nsslapd-pluginConfigArea")
347
348
349 def test_ability_to_control_behavior_of_modifiers_name(topo, _create_all_entries):
350 """Control behaviour of modifier's name
351
352 :id: 4ff16370-e7ff-11e8-838d-8c16451d917b
353 :setup: Instance with replication
354 :steps:
355 1. Turn on 'nsslapd-plugin-binddn-tracking'
356 2. Add an user
357 3. Check the creatorsname in the user entry
358 4. Check the internalCreatorsname in the user entry
359 5. Check the modifiersname in the user entry
360 6. Check the internalModifiersname in the user entry
361 7. Unset nsslapd-plugin-binddn-tracking attribute under
362 cn=config and delete the test enteries
363 :expectedresults:
364 1. Should success
365 2. Should success
366 3. Should success
367 4. Should success
368 5. Should success
369 6. Should success
370 7. Should success
371 """
372 instance1 = topo.ms["supplier1"]
373 memberof = MemberOfPlugin(instance1)
374 if (memberof.get_memberofdeferredupdate() and memberof.get_memberofdeferredupdate().lower() == "on"):
375 delay = 3
376 else:
377 delay = 0
378 configure = Config(instance1)
379 configure.replace('nsslapd-plugin-binddn-tracking', 'on')
380 instance1.restart()
381 assert configure.get_attr_val_utf8('nsslapd-plugin-binddn-tracking') == 'on'
382 user = add_user(topo, "User_autoMembers_05", "ou=Employees,{}".format(TEST_BASE),
383 "19", "18", "Supervisor")
384 time.sleep(delay)
385 # search the User DN name for the creatorsname in user entry
386 assert user.get_attr_val_utf8('creatorsname') == 'cn=directory manager'
387 # search the User DN name for the internalCreatorsname in user entry
388 assert user.get_attr_val_utf8('internalCreatorsname') == \
389 'cn=ldbm database,cn=plugins,cn=config'
390 # search the internalModifiersname in the user entry
391 assert user.get_attr_val_utf8('internalModifiersname') == \
392 'cn=MemberOf Plugin,cn=plugins,cn=config'
393 # unset nsslapd-plugin-binddn-tracking attribute
394 configure.replace('nsslapd-plugin-binddn-tracking', 'off')
395 instance1.restart()
396 # deleting test enteries of automember05 test case
397 user.delete()
398
399
400 def test_posixaccount_objectclass_automemberdefaultgroup(topo, _create_all_entries):
401 """Verify the PosixAccount user
402
403 :id: 4ff0f642-e7ff-11e8-ac88-8c16451d917b
404 :setup: Instance with replication
405 :steps:
406 1. Add users with PosixAccount ObjectClass
407 2. Verify the same user added as a member to autoMemberDefaultGroup
408 :expectedresults:
409 1. Should success
410 2. Should success
411 """
412 test_id = "autoMembers_05"
413 instance = topo.ms["supplier1"]
414 memberof = MemberOfPlugin(instance)
415 if (memberof.get_memberofdeferredupdate() and memberof.get_memberofdeferredupdate().lower() == "on"):
416 delay = 3
417 else:
418 delay = 0
419 default_group = "cn=TestDef1,CN=testuserGroups,{}".format(TEST_BASE)
420 user = add_user(topo, "User_{}".format(test_id), AUTO_MEM_SCOPE_TEST, "19", "18", "Supervisor")
421 time.sleep(delay)
422 assert check_groups(topo, default_group, user.dn, "member")
423 user.delete()
424 time.sleep(delay)
425 with pytest.raises(AssertionError):
426 assert check_groups(topo, default_group, user.dn, "member")
427
428
429 def test_duplicated_member_attributes_added_when_the_entry_is_re_created(topo, _create_all_entries):
430 """Checking whether duplicated member attributes added when the entry is re-created
431
432 :id: 4ff2afaa-e7ff-11e8-8a92-8c16451d917b
433 :setup: Instance with replication
434 :steps:
435 1. Create a user
436 2. It should present as member in all automember groups
437 3. Delete use
438 4. It should not present as member in all automember groups
439 5. Recreate same user
440 6. It should present as member in all automember groups
441 :expectedresults:
442 1. Should success
443 2. Should success
444 3. Should success
445 4. Should success
446 5. Should success
447 6. Should success
448 """
449 test_id = "autoMembers_06"
450 instance = topo.ms["supplier1"]
451 memberof = MemberOfPlugin(instance)
452 if (memberof.get_memberofdeferredupdate() and memberof.get_memberofdeferredupdate().lower() == "on"):
453 delay = 3
454 else:
455 delay = 0
456 default_group = "cn=TestDef1,CN=testuserGroups,{}".format(TEST_BASE)
457 user = add_user(topo, "User_{}".format(test_id), AUTO_MEM_SCOPE_TEST, "19", "16", "Supervisor")
458 time.sleep(delay)
459 assert check_groups(topo, default_group, user.dn, "member")
460 user.delete()
461 time.sleep(delay)
462 with pytest.raises(AssertionError):
463 assert check_groups(topo, default_group, user.dn, "member")
464 user = add_user(topo, "User_{}".format(test_id), AUTO_MEM_SCOPE_TEST, "19", "15", "Supervisor")
465 time.sleep(delay)
466 assert check_groups(topo, default_group, user.dn, "member")
467 user.delete()
468
469
470 def test_multi_valued_automemberdefaultgroup_for_hostgroups(topo, _create_all_entries):
471 """Multi-valued autoMemberDefaultGroup
472
473 :id: 4ff32a02-e7ff-11e8-99a1-8c16451d917b
474 :setup: Instance with replication
475 :steps:
476 1. Create a user
477 2. Check user is present in all Automember Groups as member
478 3. Delete the user
479 4. Check user is not present in all Automember Groups
480 :expectedresults:
481 1. Should success
482 2. Should success
483 3. Should success
484 4. Should success
485 """
486 test_id = "autoMembers_07"
487 instance = topo.ms["supplier1"]
488 memberof = MemberOfPlugin(instance)
489 if (memberof.get_memberofdeferredupdate() and memberof.get_memberofdeferredupdate().lower() == "on"):
490 delay = 3
491 else:
492 delay = 0
493 default_group1 = "cn=TestDef1,CN=testuserGroups,{}".format(TEST_BASE)
494 default_group2 = "cn=TestDef2,CN=testuserGroups,{}".format(TEST_BASE)
495 default_group3 = "cn=TestDef3,CN=testuserGroups,{}".format(TEST_BASE)
496 user = add_user(topo, "User_{}".format(test_id), AUTO_MEM_SCOPE_TEST, "19", "14", "TestEngr")
497 time.sleep(delay)
498 for grp in [default_group1, default_group2, default_group3]:
499 assert check_groups(topo, grp, user.dn, "member")
500 user.delete()
501 time.sleep(delay)
502 with pytest.raises(AssertionError):
503 assert check_groups(topo, default_group1, user.dn, "member")
504
505
506 def test_plugin_creates_member_attributes_of_the_automemberdefaultgroup(topo, _create_all_entries):
507 """Checking whether plugin creates member attributes if it already
508 exists for some of the autoMemberDefaultGroup
509
510 :id: 4ff3ba76-e7ff-11e8-9846-8c16451d917b
511 :setup: Instance with replication
512 :steps:
513 1. Add a non existing user to some groups as member
514 2. Then Create the user
515 3. Check the same user is present to other groups also as member
516 :expectedresults:
517 1. Should success
518 2. Should success
519 3. Should success
520 """
521 test_id = "autoMembers_08"
522 instance = topo.ms["supplier1"]
523 memberof = MemberOfPlugin(instance)
524 if (memberof.get_memberofdeferredupdate() and memberof.get_memberofdeferredupdate().lower() == "on"):
525 delay = 3
526 else:
527 delay = 0
528 default_group1 = "cn=TestDef1,CN=testuserGroups,{}".format(TEST_BASE)
529 default_group2 = "cn=TestDef5,CN=testuserGroups,{}".format(TEST_BASE)
530 default_group3 = "cn=TestDef3,CN=testuserGroups,{}".format(TEST_BASE)
531 add_member_attr(topo,
532 "cn=TestDef2,CN=testuserGroups,{}".format(TEST_BASE),
533 "uid=User_{},{}".format(test_id, AUTO_MEM_SCOPE_TEST), "member")
534 add_member_attr(topo,
535 "cn=TestDef4,CN=testuserGroups,{}".format(TEST_BASE),
536 "uid=User_{},{}".format(test_id, AUTO_MEM_SCOPE_TEST), "member")
537 user = add_user(topo, "User_{}".format(test_id), AUTO_MEM_SCOPE_TEST, "19", "14", "TestEngr")
538 time.sleep(delay)
539 for grp in [default_group1, default_group2, default_group3]:
540 assert check_groups(topo, grp, user.dn, "member")
541 user.delete()
542
543
544 def test_multi_valued_automemberdefaultgroup_with_uniquemember(topo, _create_all_entries):
545 """Multi-valued autoMemberDefaultGroup with uniquemember attributes
546
547 :id: 4ff4461c-e7ff-11e8-8124-8c16451d917b
548 :setup: Instance with replication
549 :steps:
550 1. Modify automember config entry to use uniquemember
551 2. Change object class for all groups which is used for automember grouping
552 3. Add user uniquemember attributes
553 4. Check uniqueMember attribute in groups
554 5. Revert the changes done above
555 :expectedresults:
556 1. Should success
557 2. Should success
558 3. Should success
559 4. Should success
560 5. Should success
561 """
562 test_id = "autoMembers_09"
563 instance = topo.ms["supplier1"]
564 memberof = MemberOfPlugin(instance)
565 if (memberof.get_memberofdeferredupdate() and memberof.get_memberofdeferredupdate().lower() == "on"):
566 delay = 3
567 else:
568 delay = 0
569 auto = AutoMembershipPlugin(topo.ms["supplier1"])
570 # Modify automember config entry to use uniquemember: cn=testuserGroups,PLUGIN_AUTO
571 AutoMembershipDefinition(
572 instance, "cn=testuserGroups,{}".format(auto.dn)).replace('autoMemberGroupingAttr',
573 "uniquemember: dn")
574 instance.restart()
575 default_group1 = "cn=TestDef1,CN=testuserGroups,{}".format(TEST_BASE)
576 default_group2 = "cn=TestDef2,CN=testuserGroups,{}".format(TEST_BASE)
577 default_group3 = "cn=TestDef3,CN=testuserGroups,{}".format(TEST_BASE)
578 default_group4 = "cn=TestDef4,CN=testuserGroups,{}".format(TEST_BASE)
579 default_group5 = "cn=TestDef5,CN=testuserGroups,{}".format(TEST_BASE)
580 for grp in (default_group1, default_group2, default_group3, default_group4, default_group5):
581 instance_of_group = Group(topo.ms["supplier1"], grp)
582 change_grp_objclass("groupOfUniqueNames", "member", instance_of_group)
583 # Add user: uid=User_{test_id}, AutoMemScope
584 user = add_user(topo, "User_{}".format(test_id), AUTO_MEM_SCOPE_TEST, "19", "14", "New")
585 # Checking groups...
586 assert user.dn.lower() in UniqueGroup(topo.ms["supplier1"],
587 default_group1).get_attr_val_utf8("uniqueMember")
588 # Delete user uid=User_{test_id},AutoMemScope
589 user.delete()
590 # Change the automember config back to using \"member\"
591 AutoMembershipDefinition(
592 instance, "cn=testuserGroups,{}".format(auto.dn)).replace('autoMemberGroupingAttr',
593 "member: dn")
594 for grp in [default_group1, default_group2, default_group3, default_group4, default_group5]:
595 instance_of_group = UniqueGroup(topo.ms["supplier1"], grp)
596 change_grp_objclass("groupOfNames", "uniquemember", instance_of_group)
597 topo.ms["supplier1"].restart()
598
599
600 def test_invalid_automembergroupingattr_member(topo, _create_all_entries):
601 """Invalid autoMemberGroupingAttr-member
602
603 :id: 4ff4b598-e7ff-11e8-a3a3-8c16451d917b
604 :setup: Instance with replication
605 :steps:
606 1. Change object class for one group which is used for automember grouping
607 2. Try to add user with invalid parameter
608 3. Check member attribute on other groups
609 4. Check member attribute on group where object class was changed
610 5. Revert the object class where it was changed
611 :expectedresults:
612 1. Should success
613 2. Should fail (ldap.UNWILLING_TO_PERFORM)
614 3. Should success
615 4. Should fail (AssertionError)
616 5. Should success
617 """
618 test_id = "autoMembers_10"
619 instance = topo.ms["supplier1"]
620 memberof = MemberOfPlugin(instance)
621 if (memberof.get_memberofdeferredupdate() and memberof.get_memberofdeferredupdate().lower() == "on"):
622 delay = 3
623 else:
624 delay = 0
625 default_group = "cn=TestDef1,CN=testuserGroups,{}".format(TEST_BASE)
626 instance_of_group = Group(topo.ms["supplier1"], default_group)
627 change_grp_objclass("groupOfUniqueNames", "member", instance_of_group)
628 with pytest.raises(ldap.UNWILLING_TO_PERFORM):
629 add_user(topo, "User_{}".format(test_id), AUTO_MEM_SCOPE_TEST, "19", "20", "Invalid")
630 time.sleep(delay)
631 with pytest.raises(AssertionError):
632 assert check_groups(topo, default_group,
633 "uid=User_{},{}".format(test_id, AUTO_MEM_SCOPE_TEST), "member")
634 change_grp_objclass("groupOfNames", "uniquemember", instance_of_group)
635
636
637 def test_valid_and_invalid_automembergroupingattr(topo, _create_all_entries):
638 """Valid and invalid autoMemberGroupingAttr
639
640 :id: 4ff4fad0-e7ff-11e8-9cbd-8c16451d917b
641 :setup: Instance with replication
642 :steps:
643 1. Change object class for some groups which is used for automember grouping
644 2. Try to add user with invalid parameter
645 3. Check member attribute on other groups
646 4. Check member attribute on groups where object class was changed
647 5. Revert the object class where it was changed
648 :expectedresults:
649 1. Should success
650 2. Should fail (ldap.UNWILLING_TO_PERFORM)
651 3. Should success
652 4. Should fail (AssertionError)
653 5. Should success
654 """
655 test_id = "autoMembers_11"
656 instance = topo.ms["supplier1"]
657 memberof = MemberOfPlugin(instance)
658 if (memberof.get_memberofdeferredupdate() and memberof.get_memberofdeferredupdate().lower() == "on"):
659 singleTXN = False
660 delay = 3
661 else:
662 singleTXN = True
663 delay = 0
664 default_group_1 = "cn=TestDef1,CN=testuserGroups,{}".format(TEST_BASE)
665 default_group_2 = "cn=TestDef2,CN=testuserGroups,{}".format(TEST_BASE)
666 default_group_3 = "cn=TestDef3,CN=testuserGroups,{}".format(TEST_BASE)
667 default_group_4 = "cn=TestDef4,CN=testuserGroups,{}".format(TEST_BASE)
668 default_group_5 = "cn=TestDef5,CN=testuserGroups,{}".format(TEST_BASE)
669 grp_4_5 = [default_group_4, default_group_5]
670 for grp in grp_4_5:
671 instance_of_group = Group(topo.ms["supplier1"], grp)
672 change_grp_objclass("groupOfUniqueNames", "member", instance_of_group)
673 with pytest.raises(ldap.UNWILLING_TO_PERFORM):
674 add_user(topo, "User_{}".format(test_id), AUTO_MEM_SCOPE_TEST, "19", "24", "MixUsers")
675 time.sleep(delay)
676 for grp in [default_group_1, default_group_2, default_group_3]:
677 assert not check_groups(topo, grp, "cn=User_{},{}".format(test_id,
678 AUTO_MEM_SCOPE_TEST), "member")
679 for grp in grp_4_5:
680 with pytest.raises(AssertionError):
681 assert check_groups(topo, grp, "cn=User_{},{}".format(test_id,
682 AUTO_MEM_SCOPE_TEST), "member")
683 for grp in grp_4_5:
684 instance_of_group = Group(topo.ms["supplier1"], grp)
685 change_grp_objclass("groupOfNames", "uniquemember", instance_of_group)
686
687
688 def test_add_regular_expressions_for_user_groups_and_check_for_member_attribute_after_adding_users(
689 topo, _create_all_entries):
690 """Regular expressions for user groups
691
692 :id: 4ff53fc2-e7ff-11e8-9a18-8c16451d917b
693 :setup: Instance with replication
694 :steps:
695 1. Add user with a match with regular expressions for user groups
696 2. check for member attribute after adding users
697 :expectedresults:
698 1. Should success
699 2. Should success
700 """
701 test_id = "autoMembers_12"
702 instance = topo.ms["supplier1"]
703 memberof = MemberOfPlugin(instance)
704 if (memberof.get_memberofdeferredupdate() and memberof.get_memberofdeferredupdate().lower() == "on"):
705 delay = 3
706 else:
707 delay = 0
708 default_group = f'cn=SuffDef1,ou=userGroups,{BASE_SUFF}'
709 user = add_user(topo, "User_{}".format(test_id), AUTO_MEM_SCOPE_BASE, "19", "0", "HR")
710 time.sleep(delay)
711 assert check_groups(topo, default_group, user.dn, "member")
712 assert number_memberof(topo, user.dn, 5)
713 user.delete()
714
715
716 LIST_FOR_PARAMETERIZATION = [
717 ("autoMembers_22", "5288", "5289", "Contractor", "5291", "5292", "Contractors"),
718 ("autoMembers_21", "1161", "1162", "Contractor", "1162", "1163", "Contractors"),
719 ("autoMembers_20", "1188", "1189", "CEO", "1191", "1192", "Contractors"),
720 ("autoMembers_15", "9288", "9289", "Manager", "9291", "9292", "Managers"),
721 ("autoMembers_14", "561", "562", "Manager", "562", "563", "Managers"),
722 ("autoMembers_13", "9788", "9789", "VPEngg", "9392", "9393", "Managers")]
723
724
725 @pytest.mark.parametrize("testid, uid, gid, role, uid2, gid2, m_grp", LIST_FOR_PARAMETERIZATION)
726 def test_matching_gid_role_inclusive_regular_expression(topo, _create_all_entries,
727 testid, uid, gid, role, uid2, gid2, m_grp):
728 """Matching gid nos and Role for the Inclusive regular expression
729
730 :id: 4ff71ce8-e7ff-11e8-b69b-8c16451d917b
731 :parametrized: yes
732 :setup: Instance with replication
733 :steps:
734 1. Create users with matching gid nos and Role for the Inclusive regular expression
735 2. It will be filtered with gidNumber, uidNumber and nsAdminGroupName
736 3. It will a match for contract_grp
737 :expectedresults:
738 1. Should success
739 2. Should success
740 3. Should success
741 """
742 contract_grp = f'cn={m_grp},ou=userGroups,{BASE_SUFF}'
743 user1 = add_user(topo, "User_{}".format(testid), AUTO_MEM_SCOPE_BASE, uid, gid, role)
744 user2 = add_user(topo, "SecondUser_{}".format(testid), AUTO_MEM_SCOPE_BASE,
745 uid2, gid2, role)
746 instance = topo.ms["supplier1"]
747 memberof = MemberOfPlugin(instance)
748 if (memberof.get_memberofdeferredupdate() and memberof.get_memberofdeferredupdate().lower() == "on"):
749 delay = 3
750 else:
751 delay = 0
752 time.sleep(delay)
753 for user_dn in [user1.dn, user2.dn]:
754 assert check_groups(topo, contract_grp, user_dn, "member")
755 assert number_memberof(topo, user1.dn, 1)
756 for user in [user1, user2]:
757 user.delete()
758
759
760 LIST_FOR_PARAMETERIZATION = [
761 ("autoMembers_26", "5788", "5789", "Intern", "Contractors", "SuffDef1", 5),
762 ("autoMembers_25", "9788", "9789", "Employee", "Contractors", "Managers", 1),
763 ("autoMembers_24", "1110", "1111", "Employee", "Contractors", "SuffDef1", 5),
764 ("autoMembers_23", "2788", "2789", "Contractor", "Contractors", "SuffDef1", 5),
765 ("autoMembers_19", "5788", "5789", "HRManager", "Managers", "SuffDef1", 5),
766 ("autoMembers_18", "6788", "6789", "Junior", "Managers", "SuffDef1", 5),
767 ("autoMembers_17", "562", "563", "Junior", "Managers", "SuffDef1", 5),
768 ("autoMembers_16", "6788", "6789", "Manager", "Managers", "SuffDef1", 5)]
769
770
771 @pytest.mark.parametrize("testid, uid, gid, role, c_grp, m_grp, number", LIST_FOR_PARAMETERIZATION)
772 def test_gid_and_role_inclusive_exclusive_regular_expression(topo, _create_all_entries,
773 testid, uid, gid, role,
774 c_grp, m_grp, number):
775 """Matching gid nos and Role for the Inclusive and Exclusive regular expression
776
777 :id: 4ff7d160-e7ff-11e8-8fbc-8c16451d917b
778 :parametrized: yes
779 :setup: Instance with replication
780 :steps:
781 1. Create user with not matching gid nos and Role for
782 the Inclusive and Exclusive regular expression
783 2. It will be filtered with gidNumber, uidNumber and nsAdminGroupName
784 3. It will not match for contract_grp(Exclusive regular expression)
785 4. It will match for default_group(Inclusive regular expression)
786 :expectedresults:
787 1. Should success
788 2. Should success
789 3. Should success
790 4. Should success
791 """
792 instance = topo.ms["supplier1"]
793 memberof = MemberOfPlugin(instance)
794 if (memberof.get_memberofdeferredupdate() and memberof.get_memberofdeferredupdate().lower() == "on"):
795 delay = 3
796 else:
797 delay = 0
798 contract_grp = f'cn={c_grp},ou=userGroups,{BASE_SUFF}'
799 default_group = f'cn={m_grp},ou=userGroups,{BASE_SUFF}'
800 user = add_user(topo, "User_{}".format(testid), AUTO_MEM_SCOPE_BASE, uid, gid, role)
801 time.sleep(delay)
802 with pytest.raises(AssertionError):
803 assert check_groups(topo, contract_grp, user.dn, "member")
804 check_groups(topo, default_group, user.dn, "member")
805 assert number_memberof(topo, user.dn, number)
806 user.delete()
807
808
809 LIST_FOR_PARAMETERIZATION = [
810 ("autoMembers_32", "555", "720", "Employee", "SubDef1", "SubDef3"),
811 ("autoMembers_31", "515", "200", "Junior", "SubDef1", "SubDef5"),
812 ("autoMembers_30", "999", "400", "Supervisor", "SubDef1", "SubDef2"),
813 ("autoMembers_28", "555", "3663", "ContractHR", "Contractors,cn=subsuffGroups",
814 "Managers,cn=subsuffGroups")]
815
816
817 @pytest.mark.parametrize("testid, uid, gid, role, c_grp, m_grp", LIST_FOR_PARAMETERIZATION)
818 def test_managers_contractors_exclusive_regex_rules_member_uid(topo, _create_all_entries,
819 testid, uid, gid, role,
820 c_grp, m_grp):
821 """Match both managers and contractors exclusive regex rules
822
823 :id: 4ff8be18-e7ff-11e8-94aa-8c16451d917b
824 :parametrized: yes
825 :setup: Instance with replication
826 :steps:
827 1. Add Users to match both managers and contractors exclusive regex rules,
828 memberUid created in Default grp
829 2. It will be filtered with gidNumber, uidNumber and nsAdminGroupName
830 3. It will match for default_group1 and default_group2(Inclusive regular expression)
831 :expectedresults:
832 1. Should success
833 2. Should success
834 3. Should success
835 """
836 default_group1 = f'cn={c_grp},{SUBSUFFIX}'
837 default_group2 = f'cn={m_grp},{SUBSUFFIX}'
838 instance = topo.ms["supplier1"]
839 memberof = MemberOfPlugin(instance)
840 if (memberof.get_memberofdeferredupdate() and memberof.get_memberofdeferredupdate().lower() == "on"):
841 delay = 3
842 else:
843 delay = 0
844 user = add_user(topo, "User_{}".format(testid), AUTO_MEM_SCOPE_BASE, uid, gid, role)
845 time.sleep(delay)
846 for group in [default_group1, default_group2]:
847 assert check_groups(topo, group, user.dn, "memberuid")
848 user.delete()
849
850
851 LIST_FOR_PARAMETERIZATION = [
852 ("autoMembers_27", "595", "690", "ContractHR", "Managers", "Contractors"),
853 ("autoMembers_29", "8195", "2753", "Employee", "Contractors", "Managers"),
854 ("autoMembers_33", "545", "3333", "Supervisor", "Contractors", "Managers"),
855 ("autoMembers_34", "8195", "693", "Temporary", "Managers", "Contractors")]
856
857
858 @pytest.mark.parametrize("testid, uid, gid, role, c_grp, m_grp", LIST_FOR_PARAMETERIZATION)
859 def test_managers_inclusive_regex_rule(topo, _create_all_entries,
860 testid, uid, gid, role, c_grp, m_grp):
861 """Match managers inclusive regex rule, and no
862 inclusive/exclusive Contractors regex rules
863
864 :id: 4ff8d862-e7ff-11e8-b688-8c16451d917b
865 :parametrized: yes
866 :setup: Instance with replication
867 :steps:
868 1. Add User to match managers inclusive regex rule, and no
869 inclusive/exclusive Contractors regex rules
870 2. It will be filtered with gidNumber, uidNumber and nsAdminGroupName(Supervisor)
871 3. It will match for managers_grp(Inclusive regular expression)
872 4. It will not match for contract_grp(Exclusive regular expression)
873 :expectedresults:
874 1. Should success
875 2. Should success
876 3. Should success
877 4. Should success
878 """
879 contract_grp = f'cn={c_grp},cn=subsuffGroups,{SUBSUFFIX}'
880 managers_grp = f'cn={m_grp},cn=subsuffGroups,{SUBSUFFIX}'
881 user = add_user(topo, "User_{}".format(testid), AUTO_MEM_SCOPE_BASE, uid, gid, role)
882 check_groups(topo, managers_grp, user.dn, "memberuid")
883 with pytest.raises(AssertionError):
884 assert check_groups(topo, contract_grp, user.dn, "memberuid")
885 user.delete()
886
887
888 def test_reject_invalid_config_and_we_donot_deadlock_the_server(topo, _create_all_entries):
889 """Verify DS reject invalid config, and we don't deadlock the server
890
891 :id: 4ff90c38-e7ff-11e8-b72a-8c16451d917b
892 :setup: Instance with replication
893 :steps:
894 1. Verify DS reject invalid config,
895 2. This operation don't deadlock the server
896 :expectedresults:
897 1. Should success
898 2. Should success
899 """
900 # Changing config area to dc=automembers,dc=com
901 instance = AutoMembershipPlugin(topo.ms["supplier1"])
902 instance.replace("nsslapd-pluginConfigArea", BASE_SUFF)
903 topo.ms["supplier1"] .restart()
904 # Attempting to add invalid config...
905 automembers = AutoMembershipDefinitions(topo.ms["supplier1"], BASE_SUFF)
906 with pytest.raises(ldap.UNWILLING_TO_PERFORM):
907 automembers.create(properties={
908 'cn': 'userGroups',
909 "autoMemberScope": BASE_SUFF,
910 "autoMemberFilter": "objectclass=posixAccount",
911 "autoMemberDefaultGroup": f'cn=SuffDef1,ou=userGroups,{BASE_SUFF}',
912 "autoMemberGroupingAttr": "member: dn"
913 })
914 # Verify server is still working
915 automembers = AutoMembershipRegexRules(topo.ms["supplier1"],
916 f'cn=userGroups,cn=Auto Membership Plugin,'
917 f'cn=plugins,cn=config')
918 with pytest.raises(ldap.ALREADY_EXISTS):
919 automembers.create(properties={
920 'cn': 'Managers',
921 'description': f'Group placement for Managers',
922 'autoMemberTargetGroup': [f'cn=Managers,ou=userGroups,{BASE_SUFF}'],
923 'autoMemberInclusiveRegex': [
924 "gidNumber=^9",
925 "nsAdminGroupName=^Manager",
926 ],
927 })
928
929 # Adding first user...
930 for uid in range(300, 302):
931 UserAccounts(topo.ms["supplier1"], BASE_SUFF, rdn=None).create_test_user(uid=uid, gid=uid)
932 # Adding this line code to remove the automembers plugin configuration.
933 instance.remove("nsslapd-pluginConfigArea", BASE_SUFF)
934 topo.ms["supplier1"] .restart()
935
936
937 @pytest.fixture(scope="module")
938 def _startuptask(topo):
939 """
940 Fixture module that will change required entries for test cases.
941 """
942 for Configs in ["cn=Managers,cn=subsuffGroups",
943 "cn=Contractors,cn=subsuffGroups",
944 "cn=testuserGroups",
945 "cn=subsuffGroups",
946 "cn=hostGroups"]:
947 AutoMembershipDefinition(topo.ms["supplier1"], f'{Configs},{PLUGIN_AUTO}').delete()
948 AutoMembershipDefinition(topo.ms["supplier1"], "cn=userGroups,{}".format(PLUGIN_AUTO)).replace(
949 'autoMemberScope', 'ou=TaskEmployees,dc=autoMembers,dc=com')
950 topo.ms['supplier1'].restart()
951
952
953 @pytest.fixture(scope="function")
954 def _fixture_for_build_task(request, topo):
955 supplier = topo.ms['supplier1']
956 managers_grp = "cn=Managers,ou=userGroups,{}".format(BASE_SUFF)
957 contract_grp = "cn=Contractors,ou=userGroups,{}".format(BASE_SUFF)
958
959 for grp in (managers_grp, contract_grp):
960 group = Group(supplier, grp)
961 try:
962 group.remove_all('member')
963 except ldap.NO_SUCH_ATTRIBUTE:
964 pass
965
966 def finof():
967 auto_mem_scope = "ou=TaskEmployees,{}".format(BASE_SUFF)
968 for user in nsAdminGroups(supplier, auto_mem_scope, rdn=None).list():
969 user.delete()
970
971 request.addfinalizer(finof)
972
973
974 def bulk_check_groups(topo, GROUP_DN, MEMBATTR, TOTAL_MEM):
975 assert len(nsAdminGroup(topo, GROUP_DN).get_attr_vals_utf8(MEMBATTR)) == TOTAL_MEM
976
977
978 def test_automemtask_re_build_task(topo, _create_all_entries, _startuptask, _fixture_for_build_task):
979 """
980 :id: 4ff973a8-e7ff-11e8-a89b-8c16451d917b
981 :setup: 4 Instances with replication
982 :steps:
983 1. Add 10 users and enable autoMembers plug-in
984 2. Run automembers re-build task to create the member attributes
985 3. Search for any error logs
986 :expectedresults:
987 1. Success
988 2. Success
989 3. Success
990 """
991 supplier = topo.ms['supplier1']
992 testid = "autoMemTask_01"
993 auto_mem_scope = "ou=TaskEmployees,{}".format(BASE_SUFF)
994 managers_grp = "cn=Managers,ou=userGroups,{}".format(BASE_SUFF)
995 contract_grp = "cn=Contractors,ou=userGroups,{}".format(BASE_SUFF)
996 user_rdn = "User_{}".format(testid)
997 # make sure the retro changelog is disabled
998 RetroChangelogPlugin(supplier).disable()
999 AutoMembershipPlugin(supplier).disable()
1000 supplier.restart()
1001 for i in range(10):
1002 add_user(topo, "{}{}".format(user_rdn, str(i)), auto_mem_scope, str(1188), str(1189), "Manager")
1003 for grp in (managers_grp, contract_grp):
1004 with pytest.raises(AssertionError):
1005 assert check_groups(topo, grp, f'uid=User_autoMemTask_010,{auto_mem_scope}', 'member')
1006 AutoMembershipPlugin(supplier).enable()
1007 supplier.restart()
1008 error_string = "automember_rebuild_task_thread"
1009 AutomemberRebuildMembershipTask(supplier).create(properties={
1010 'basedn': auto_mem_scope,
1011 'filter': "objectClass=posixAccount"
1012 })
1013 time.sleep(10)
1014
1015 # Search for any error logs
1016 assert not supplier.searchErrorsLog(error_string)
1017 for grp in (managers_grp, contract_grp):
1018 bulk_check_groups(supplier, grp, "member", 10)
1019
1020
1021 def ldif_check_groups(USERS_DN, MEMBATTR, TOTAL_MEM, LDIF_FILE):
1022 study = open('{}'.format(LDIF_FILE), 'r')
1023 study_ready = study.read()
1024 assert len(re.findall("{}: {}".format(MEMBATTR, USERS_DN.lower()), study_ready)) == TOTAL_MEM
1025
1026
1027 def check_file_exists(export_ldif):
1028 count = 0
1029 while not os.path.exists(export_ldif) and count < 3:
1030 time.sleep(1)
1031 count += 1
1032
1033 count = 0
1034 while (os.stat(export_ldif).st_size == 0) and count < 3:
1035 time.sleep(1)
1036 count += 1
1037
1038 if os.path.exists(export_ldif) and os.stat(export_ldif).st_size != 0:
1039 return True
1040 else:
1041 return False
1042
1043
1044 def test_automemtask_export_task(topo, _create_all_entries, _startuptask, _fixture_for_build_task):
1045 """
1046 :id: 4ff98b18-e7ff-11e8-872a-8c16451d917b
1047 :setup: 4 Instances with replication
1048 :steps:
1049 1. Add 10 users and enable autoMembers plug-in
1050 2. Run automembers export task to create an ldif file with member attributes
1051 :expectedresults:
1052 1. Success
1053 2. Success
1054 """
1055 supplier = topo.ms['supplier1']
1056 p = Paths('supplier1')
1057 testid = "autoMemTask_02"
1058 auto_mem_scope = "ou=TaskEmployees,{}".format(BASE_SUFF)
1059 managers_grp = "cn=Managers,ou=userGroups,{}".format(BASE_SUFF)
1060 user_rdn = "User_{}".format(testid)
1061 # Disabling plugin
1062 AutoMembershipPlugin(supplier).disable()
1063 supplier.restart()
1064 for i in range(10):
1065 add_user(topo, "{}{}".format(user_rdn, str(i)), auto_mem_scope, str(2788), str(2789), "Manager")
1066 with pytest.raises(AssertionError):
1067 bulk_check_groups(supplier, managers_grp, "member", 10)
1068 AutoMembershipPlugin(supplier).enable()
1069 supplier.restart()
1070 export_ldif = p.backup_dir + "/Out_Export_02.ldif"
1071 if os.path.exists(export_ldif):
1072 os.remove(export_ldif)
1073 exp_task = Tasks(supplier)
1074 exp_task.automemberExport(suffix=auto_mem_scope, fstr='objectclass=posixAccount', ldif_out=export_ldif)
1075 check_file_exists(export_ldif)
1076 ldif_check_groups("cn={}".format(user_rdn), "member", 10, export_ldif)
1077 os.remove(export_ldif)
1078
1079
1080 def test_automemtask_mapping(topo, _create_all_entries, _startuptask, _fixture_for_build_task):
1081 """
1082 :id: 4ff9a206-e7ff-11e8-bf59-8c16451d917b
1083 :setup: 4 Instances with replication
1084 :steps:
1085 1. Add 10 users and enable autoMembers plug-in
1086 2. Run automembers Mapping task with input/output ldif files
1087 :expectedresults:
1088 1. Should success
1089 2. Should success
1090 """
1091 supplier = topo.ms['supplier1']
1092 p = Paths('supplier1')
1093 testid = "autoMemTask_02"
1094 auto_mem_scope = "ou=TaskEmployees,{}".format(BASE_SUFF)
1095 user_rdn = "User_{}".format(testid)
1096 export_ldif = p.backup_dir+"/Out_Export_02.ldif"
1097 output_ldif3 = p.backup_dir+"/Output_03.ldif"
1098 for file in [export_ldif, output_ldif3]:
1099 if os.path.exists(file):
1100 os.remove(file)
1101 for i in range(10):
1102 add_user(topo, "{}{}".format(user_rdn, str(i)), auto_mem_scope, str(2788), str(2789), "Manager")
1103 ExportTask(supplier).export_suffix_to_ldif(ldiffile=export_ldif, suffix=BASE_SUFF)
1104 check_file_exists(export_ldif)
1105 map_task = Tasks(supplier)
1106 map_task.automemberMap(ldif_in=export_ldif, ldif_out=output_ldif3)
1107 check_file_exists(output_ldif3)
1108 ldif_check_groups("cn={}".format(user_rdn), "member", 10, output_ldif3)
1109 for file in [export_ldif, output_ldif3]:
1110 os.remove(file)
1111
1112
1113 def test_automemtask_re_build(topo, _create_all_entries, _startuptask, _fixture_for_build_task):
1114 """
1115 :id: 4ff9b944-e7ff-11e8-ad35-8c16451d917b
1116 :setup: 4 Instances with replication
1117 :steps:
1118 1. Add 10 users with inetOrgPerson object class
1119 2. Run automembers re-build task to create the member attributes, exp to FAIL
1120 :expectedresults:
1121 1. Should success
1122 2. Should not success
1123 """
1124 supplier = topo.ms['supplier1']
1125 testid = "autoMemTask_04"
1126 auto_mem_scope = "ou=TaskEmployees,{}".format(BASE_SUFF)
1127 managers_grp = "cn=Managers,ou=userGroups,{}".format(BASE_SUFF)
1128 user_rdn = "User_{}".format(testid)
1129 # Disabling plugin
1130 AutoMembershipPlugin(supplier).disable()
1131 supplier.restart()
1132 for number in range(10):
1133 add_user(topo, f'{user_rdn}{number}', auto_mem_scope, str(number), str(number), "Manager")
1134 with pytest.raises(AssertionError):
1135 bulk_check_groups(supplier, managers_grp, "member", 10)
1136 # Enabling plugin
1137 AutoMembershipPlugin(supplier).enable()
1138 supplier.restart()
1139 AutomemberRebuildMembershipTask(supplier).create(properties={
1140 'basedn': auto_mem_scope,
1141 'filter': "objectClass=inetOrgPerson"
1142 })
1143 time.sleep(10)
1144 with pytest.raises(AssertionError):
1145 bulk_check_groups(supplier, managers_grp, "member", 10)
1146
1147
1148 def test_automemtask_export(topo, _create_all_entries, _startuptask, _fixture_for_build_task):
1149 """
1150 :id: 4ff9cf74-e7ff-11e8-b712-8c16451d917b
1151 :setup: 4 Instances with replication
1152 :steps:
1153 1. Add 10 users with inetOrgPerson objectClass
1154 2. Run automembers export task to create an ldif file with member attributes, exp to FAIL
1155 :expectedresults:
1156 1. Should success
1157 2. Should not success
1158 """
1159 supplier = topo.ms['supplier1']
1160 p = Paths('supplier1')
1161 testid = "autoMemTask_05"
1162 auto_mem_scope = "ou=TaskEmployees,{}".format(BASE_SUFF)
1163 managers_grp = "cn=Managers,ou=userGroups,{}".format(BASE_SUFF)
1164 user_rdn = "User_{}".format(testid)
1165 # Disabling plugin
1166 AutoMembershipPlugin(supplier).disable()
1167 supplier.restart()
1168 for number in range(10):
1169 add_user(topo, f'{user_rdn}{number}', auto_mem_scope, str(number), str(number), "Manager")
1170 with pytest.raises(AssertionError):
1171 bulk_check_groups(supplier, managers_grp, "member", 10)
1172 # Enabling plugin
1173 AutoMembershipPlugin(supplier).enable()
1174 supplier.restart()
1175 export_ldif = p.backup_dir + "/Out_Export_02.ldif"
1176 if os.path.exists(export_ldif):
1177 os.remove(export_ldif)
1178 exp_task = Tasks(supplier)
1179 exp_task.automemberExport(suffix=auto_mem_scope, fstr='objectclass=inetOrgPerson', ldif_out=export_ldif)
1180 check_file_exists(export_ldif)
1181 with pytest.raises(AssertionError):
1182 ldif_check_groups("uid={}".format(user_rdn), "member", 10, export_ldif)
1183 os.remove(export_ldif)
1184
1185
1186 def test_automemtask_run_re_build(topo, _create_all_entries, _startuptask, _fixture_for_build_task):
1187 """
1188 :id: 4ff9e5c2-e7ff-11e8-943e-8c16451d917b
1189 :setup: 4 Instances with replication
1190 :steps:
1191 1. Add 10 users with inetOrgPerson obj class
1192 2. Change plugin config
1193 3. Enable plug-in and run re-build task to create the member attributes
1194 :expectedresults:
1195 1. Should success
1196 2. Should success
1197 3. Should success
1198 """
1199 supplier = topo.ms['supplier1']
1200 p = Paths('supplier1')
1201 testid = "autoMemTask_06"
1202 auto_mem_scope = "ou=TaskEmployees,{}".format(BASE_SUFF)
1203 managers_grp = "cn=Managers,ou=userGroups,{}".format(BASE_SUFF)
1204 user_rdn = "User_{}".format(testid)
1205 # Disabling plugin
1206 AutoMembershipPlugin(supplier).disable()
1207 supplier.restart()
1208 for number in range(10):
1209 add_user(topo, f'{user_rdn}{number}', auto_mem_scope, '111', '111', "Manager")
1210 for user in nsAdminGroups(supplier, auto_mem_scope, rdn=None).list():
1211 user.add('objectclass', 'inetOrgPerson')
1212 AutoMembershipDefinition(supplier,
1213 f'cn=userGroups,{PLUGIN_AUTO}').replace('autoMemberFilter',
1214 "objectclass=inetOrgPerson")
1215 supplier.restart()
1216 with pytest.raises(AssertionError):
1217 bulk_check_groups(supplier, managers_grp, "member", 10)
1218 AutoMembershipPlugin(supplier).enable()
1219 supplier.restart()
1220 AutomemberRebuildMembershipTask(supplier).create(properties={
1221 'basedn': auto_mem_scope,
1222 'filter': "objectClass=inetOrgPerson"})
1223 time.sleep(10)
1224 bulk_check_groups(supplier, managers_grp, "member", 10)
1225 AutoMembershipDefinition(supplier,
1226 f'cn=userGroups,{PLUGIN_AUTO}').replace('autoMemberFilter',
1227 "objectclass=posixAccount")
1228 supplier.restart()
1229
1230
1231 def test_automemtask_run_export(topo, _create_all_entries, _startuptask, _fixture_for_build_task):
1232 """
1233 :id: 4ff9fba2-e7ff-11e8-a5ec-8c16451d917b
1234 :setup: 4 Instances with replication
1235 :steps:
1236 1. Add 10 users with inetOrgPerson objectClass
1237 2. change plugin config
1238 3. Run export task to create an ldif file with member attributes
1239 :expectedresults:
1240 1. Should success
1241 2. Should success
1242 3. Should success
1243 """
1244 supplier = topo.ms['supplier1']
1245 p = Paths('supplier1')
1246 testid = "autoMemTask_07"
1247 auto_mem_scope = "ou=TaskEmployees,{}".format(BASE_SUFF)
1248 managers_grp = "cn=Managers,ou=userGroups,{}".format(BASE_SUFF)
1249 user_rdn = "User_{}".format(testid)
1250 # Disabling plugin
1251 AutoMembershipPlugin(supplier).disable()
1252 supplier.restart()
1253 for number in range(10):
1254 add_user(topo, f'{user_rdn}{number}', auto_mem_scope, '222', '222', "Manager")
1255 for user in nsAdminGroups(supplier, auto_mem_scope, rdn=None).list():
1256 user.add('objectclass', 'inetOrgPerson')
1257 AutoMembershipDefinition(supplier, f'cn=userGroups,{PLUGIN_AUTO}').replace('autoMemberFilter',
1258 "objectclass=inetOrgPerson")
1259 supplier.restart()
1260 # Enabling plugin
1261 AutoMembershipPlugin(supplier).enable()
1262 supplier.restart()
1263 with pytest.raises(AssertionError):
1264 bulk_check_groups(supplier, managers_grp, "member", 10)
1265 export_ldif = p.backup_dir + "/Out_Export_02.ldif"
1266 if os.path.exists(export_ldif):
1267 os.remove(export_ldif)
1268 exp_task = Tasks(supplier)
1269 exp_task.automemberExport(suffix=auto_mem_scope, fstr='objectclass=inetOrgPerson', ldif_out=export_ldif)
1270 check_file_exists(export_ldif)
1271 ldif_check_groups("cn={}".format(user_rdn), "member", 10, export_ldif)
1272 AutoMembershipDefinition(supplier, f'cn=userGroups,{PLUGIN_AUTO}').\
1273 replace('autoMemberFilter', "objectclass=posixAccount")
1274
1275
1276 if __name__ == "__main__":
1277 CURRENT_FILE = os.path.realpath(__file__)
1278 pytest.main("-s -v %s" % CURRENT_FILE)