def test_negative_create_external_with_invalid_name(self):
"""Create External AD User Group with random name
@id: 2fd12301-9a35-49f1-9723-2b74551414c2
@Steps:
1. Create an UserGroup.
2. Assign some roles to UserGroup.
3. Create an External AD UserGroup with any random name.
@Assert: Creation of External AD User Group should not be possible with
random name.
"""
with Session(self.browser) as session:
make_usergroup(
session,
name=self.usergroup_name,
roles=['admin'],
ext_usergrp=gen_string('alpha'),
ext_authsourceid='LDAP-' + self.ldap_server_name,
)
self.assertIsNotNone(self.usergroup.wait_until_element(
common_locators['haserror']
))
self.assertIsNone(self.usergroup.search(self.usergroup_name))
def test_create_external_adusergroup_2(self):
"""@Test: Create another External AD User Group with same name
@Feature: LDAP Authentication - Active Directory - create
@Steps:
1. Create an UserGroup.
2. Assign some roles to UserGroup.
3. create an External AD UserGroup as per the UserGroup name in AD.
4. Repeat steps 1) and 2) and provide the same UserGroup name for
step 3).
@Assert: Creation of External AD User Group should not be possible with
same name.
"""
with Session(self.browser) as session:
make_usergroup(
session,
name=self.usergroup_name,
roles=['admin'],
ext_usergrp='foobargroup',
ext_authsourceid='LDAP-' + self.ldap_server_name,
)
self.assertIsNotNone(self.usergroup.search(self.usergroup_name))
make_usergroup(
session,
name=self.usergroup_name2,
roles=['admin'],
ext_usergrp='foobargroup',
ext_authsourceid='LDAP-' + self.ldap_server_name,
)
self.assertIsNone(self.usergroup.search(self.usergroup_name2))
def test_negative_create_external_with_same_name(self):
"""Attempt to create two User Groups with same External AD User Group
name
@id: 8f2cde96-644a-4729-880a-65a22c7e7262
@Steps:
1. Create an UserGroup.
2. Assign External AD UserGroup as per the UserGroup name in AD.
3. Repeat steps 1) and 2), but provide the same external UserGroup name
@Assert: Creation of User Group should not be possible with same
External AD User Group name.
"""
new_usergroup_name = gen_string('alpha')
with Session(self.browser) as session:
make_usergroup(
session,
name=self.usergroup_name,
roles=['admin'],
ext_usergrp='foobargroup',
ext_authsourceid='LDAP-' + self.ldap_server_name,
)
self.assertIsNotNone(self.usergroup.search(self.usergroup_name))
make_usergroup(
session,
name=new_usergroup_name,
roles=['admin'],
ext_usergrp='foobargroup',
ext_authsourceid='LDAP-' + self.ldap_server_name,
)
self.assertIsNone(self.usergroup.search(new_usergroup_name))
def test_negative_create_external_with_same_name(self):
"""Attempt to create two User Groups with same External AD User Group
name
@id: 8f2cde96-644a-4729-880a-65a22c7e7262
@Steps:
1. Create an UserGroup.
2. Assign External AD UserGroup as per the UserGroup name in AD.
3. Repeat steps 1) and 2), but provide the same external UserGroup name
@Assert: Creation of User Group should not be possible with same
External AD User Group name.
"""
new_usergroup_name = gen_string('alpha')
with Session(self.browser) as session:
make_usergroup(
session,
name=self.usergroup_name,
roles=['admin'],
ext_usergrp='foobargroup',
ext_authsourceid='LDAP-' + self.ldap_server_name,
)
self.assertIsNotNone(self.usergroup.search(self.usergroup_name))
make_usergroup(
session,
name=new_usergroup_name,
roles=['admin'],
ext_usergrp='foobargroup',
ext_authsourceid='LDAP-' + self.ldap_server_name,
)
self.assertIsNone(self.usergroup.search(new_usergroup_name))
def test_negative_create_external_with_same_name(self):
"""Attempt to create two User Groups with same External AD User Group
name
@Feature: LDAP Authentication - Active Directory - create
@Steps:
1. Create an UserGroup.
2. Assign External AD UserGroup as per the UserGroup name in AD.
3. Repeat steps 1) and 2), but provide the same external UserGroup name
@Assert: Creation of User Group should not be possible with same
External AD User Group name.
"""
new_usergroup_name = gen_string("alpha")
with Session(self.browser) as session:
make_usergroup(
session,
name=self.usergroup_name,
roles=["admin"],
ext_usergrp="foobargroup",
ext_authsourceid="LDAP-" + self.ldap_server_name,
)
self.assertIsNotNone(self.usergroup.search(self.usergroup_name))
make_usergroup(
session,
name=new_usergroup_name,
roles=["admin"],
ext_usergrp="foobargroup",
ext_authsourceid="LDAP-" + self.ldap_server_name,
)
self.assertIsNone(self.usergroup.search(new_usergroup_name))
def test_positive_update_external_roles(self):
"""Added AD UserGroup roles get pushed down to user
@feature: LDAP Authentication - Active directory - update
@setup: assign additional roles to the UserGroup
@steps:
1. Create an UserGroup.
2. Assign some roles to UserGroup.
3. Create an External AD UserGroup as per the UserGroup name in AD.
4. Login to sat6 with the AD user.
5. Assign additional roles to the UserGroup.
6. Login to sat6 with LDAP user that is part of aforementioned
UserGroup.
@assert: User has access to all NEW functional areas that are assigned
to aforementioned UserGroup.
"""
self.check_external_user()
foreman_role = gen_string("alpha")
katello_role = gen_string("alpha")
org_name = gen_string("alpha")
loc_name = gen_string("alpha")
with Session(self.browser) as session:
make_role(session, name=foreman_role)
self.role.update(
foreman_role, add_permission=True, permission_list=PERMISSIONS["Location"], resource_type="Location"
)
make_usergroup(
session,
name=self.usergroup_name,
roles=[foreman_role],
ext_usergrp="foobargroup",
ext_authsourceid="LDAP-" + self.ldap_server_name,
)
self.assertIsNotNone(self.usergroup.search(self.usergroup_name))
set_context(session, org=ANY_CONTEXT["org"])
self.user.update(
username=self.ldap_user_name,
authorized_by="LDAP-" + self.ldap_server_name,
password=self.ldap_user_passwd,
)
with Session(self.browser, self.ldap_user_name, self.ldap_user_passwd) as session:
make_loc(session, name=loc_name)
self.assertIsNotNone(self.location.search(loc_name))
with Session(self.browser) as session:
make_role(session, name=katello_role)
self.role.update(
katello_role,
add_permission=True,
permission_list=PERMISSIONS["Organization"],
resource_type="Organization",
)
self.usergroup.update(self.usergroup_name, new_roles=[katello_role], entity_select=True)
self.usergroup.refresh_ext_group(self.usergroup_name, "foobargroup")
self.assertIsNotNone(self.usergroup.wait_until_element(common_locators["notif.success"]))
with Session(self.browser, self.ldap_user_name, self.ldap_user_passwd) as session:
make_org(session, org_name=org_name)
self.assertIsNotNone(self.org.search(org_name))
def test_positive_create_with_name(self):
"""Create new Usergroup using different names
:id: 43e70c8d-455e-4da8-9c69-ab80dae2a0bc
:expectedresults: Usergroup is created successfully
:CaseImportance: Critical
"""
user_name = gen_string('alpha')
# Create a new user
entities.User(
login=user_name,
password=gen_string('alpha'),
organization=[self.organization],
).create()
with Session(self) as session:
for group_name in generate_strings_list():
with self.subTest(group_name):
make_usergroup(
session,
name=group_name,
users=[user_name],
org=self.organization.name,
)
self.assertIsNotNone(self.usergroup.search(group_name))
def test_adusergroup_admin_role(self):
"""@Test: Associate Admin role to User Group.
[belonging to external AD User Group.]
@Feature: LDAP Authentication - Active Directory - associate Admin
role
@Steps:
1. Create an UserGroup.
2. Assign admin role to UserGroup.
3. create and associate an External AD UserGroup.
@Assert: Whether a User belonging to User Group is able to
access all the pages.
"""
strategy, value = locators['login.loggedin']
with Session(self.browser) as session:
make_usergroup(
session,
name=self.usergroup_name,
roles=['admin'],
ext_usergrp='foobargroup',
ext_authsourceid='LDAP-' + self.ldap_server_name,
)
self.assertIsNotNone(self.usergroup.search(self.usergroup_name))
with Session(
self.browser,
self.ldap_user_name,
self.ldap_user_passwd,
) as session:
self.assertIsNotNone(self.login.wait_until_element(
(strategy, value % self.ldap_user_name)
))
def test_positive_delete_with_user(self):
"""Delete an Usergroup that contains a user
@Feature: Usergroup - Positive Delete
@Assert: Usergroup is deleted but not the added user
"""
user_name = gen_string('alpha')
group_name = gen_string('utf8')
# Create a new user
entities.User(
login=user_name,
password=gen_string('alpha'),
organization=[self.organization],
).create()
with Session(self.browser) as session:
make_usergroup(
session,
name=group_name,
users=[user_name],
org=self.organization.name,
)
self.usergroup.delete(group_name)
self.assertIsNotNone(self.user.search(user_name))
def test_positive_create_with_name(self):
"""Create new Usergroup using different names
:id: 43e70c8d-455e-4da8-9c69-ab80dae2a0bc
:expectedresults: Usergroup is created successfully
:CaseImportance: Critical
"""
user_name = gen_string('alpha')
# Create a new user
entities.User(
login=user_name,
password=gen_string('alpha'),
organization=[self.organization],
).create()
with Session(self) as session:
for group_name in generate_strings_list():
with self.subTest(group_name):
make_usergroup(
session,
name=group_name,
users=[user_name],
org=self.organization.name,
)
self.assertIsNotNone(self.usergroup.search(group_name))
def test_positive_delete_with_user(self):
"""Delete an Usergroup that contains a user
@id: 2bda3db5-f54f-412f-831f-8e005631f271
@Assert: Usergroup is deleted but not the added user
@CaseLevel: Integration
"""
user_name = gen_string('alpha')
group_name = gen_string('utf8')
# Create a new user
entities.User(
login=user_name,
password=gen_string('alpha'),
organization=[self.organization],
).create()
with Session(self.browser) as session:
make_usergroup(
session,
name=group_name,
users=[user_name],
org=self.organization.name,
)
self.usergroup.delete(group_name)
self.assertIsNotNone(self.user.search(user_name))
def test_positive_create_external(self):
"""Create External AD User Group as per AD group
:id: b5e64316-55b9-4480-8701-308e91be9344
:Steps:
1. Create an UserGroup.
2. Assign some roles to UserGroup.
3. Create an External AD UserGroup as per the UserGroup name in AD
:expectedresults: Whether creation of External AD User Group is
possible.
:CaseImportance: Critical
"""
with Session(self) as session:
make_usergroup(
session,
name=self.usergroup_name,
roles=['admin'],
ext_usergrp='foobargroup',
ext_authsourceid='LDAP-' + self.ldap_server_name,
)
self.assertIsNotNone(self.usergroup.search(self.usergroup_name))
def test_positive_create_external(self):
"""Create External AD User Group as per AD group
:id: b5e64316-55b9-4480-8701-308e91be9344
:Steps:
1. Create an UserGroup.
2. Assign some roles to UserGroup.
3. Create an External AD UserGroup as per the UserGroup name in AD
:expectedresults: Whether creation of External AD User Group is
possible.
:CaseImportance: Critical
"""
with Session(self.browser) as session:
make_usergroup(
session,
name=self.usergroup_name,
roles=['admin'],
ext_usergrp='foobargroup',
ext_authsourceid='LDAP-' + self.ldap_server_name,
)
self.assertIsNotNone(self.usergroup.search(self.usergroup_name))
def test_positive_delete_with_user(self):
"""Delete an Usergroup that contains a user
@id: 2bda3db5-f54f-412f-831f-8e005631f271
@Assert: Usergroup is deleted but not the added user
@CaseLevel: Integration
"""
user_name = gen_string('alpha')
group_name = gen_string('utf8')
# Create a new user
entities.User(
login=user_name,
password=gen_string('alpha'),
organization=[self.organization],
).create()
with Session(self.browser) as session:
make_usergroup(
session,
name=group_name,
users=[user_name],
org=self.organization.name,
)
self.usergroup.delete(group_name)
self.assertIsNotNone(self.user.search(user_name))
def test_negative_create_external_with_invalid_name(self):
"""Create External AD User Group with random name
:id: 2fd12301-9a35-49f1-9723-2b74551414c2
:Steps:
1. Create an UserGroup.
2. Assign some roles to UserGroup.
3. Create an External AD UserGroup with any random name.
:expectedresults: Creation of External AD User Group should not be
possible with random name.
:CaseImportance: Critical
"""
with Session(self) as session:
make_usergroup(
session,
name=self.usergroup_name,
roles=['admin'],
ext_usergrp=gen_string('alpha'),
ext_authsourceid='LDAP-' + self.ldap_server_name,
)
self.assertIsNotNone(self.usergroup.wait_until_element(
common_locators['haserror']
))
self.assertIsNone(self.usergroup.search(self.usergroup_name))
def test_positive_add_foreman_role(self):
"""Associate foreman roles to User Group.
[belonging to external AD User Group.]
@id: c11fbf85-e144-4576-99e3-1ba111479f0f
@Steps:
1. Create an UserGroup.
2. Assign some foreman roles to UserGroup.
3. Create and associate an External AD UserGroup.
@Assert: Whether a User belonging to User Group is able to access
foreman entities as per roles.
@CaseLevel: Integration
"""
self.check_external_user()
strategy, value = locators['login.loggedin']
foreman_role = gen_string('alpha')
location_name = gen_string('alpha')
with Session(self.browser) as session:
make_role(session, name=foreman_role)
self.role.update(
foreman_role,
add_permission=True,
permission_list=PERMISSIONS['Location'],
resource_type='Location',
)
make_usergroup(
session,
name=self.usergroup_name,
roles=[foreman_role],
ext_usergrp='foobargroup',
ext_authsourceid="LDAP-" + self.ldap_server_name,
)
self.assertIsNotNone(self.usergroup.search(self.usergroup_name))
set_context(session, org=ANY_CONTEXT['org'])
self.user.update(
username=self.ldap_user_name,
authorized_by='LDAP-' + self.ldap_server_name,
new_password=self.ldap_user_passwd,
password_confirmation=self.ldap_user_passwd,
)
with Session(
self.browser,
self.ldap_user_name,
self.ldap_user_passwd,
) as session:
self.assertIsNotNone(self.login.wait_until_element(
(strategy, value % self.ldap_user_name)
))
make_loc(session, name=location_name)
self.assertIsNotNone(self.location.search(location_name))
def test_positive_add_foreman_role(self):
"""Associate foreman roles to User Group.
[belonging to external AD User Group.]
@id: c11fbf85-e144-4576-99e3-1ba111479f0f
@Steps:
1. Create an UserGroup.
2. Assign some foreman roles to UserGroup.
3. Create and associate an External AD UserGroup.
@Assert: Whether a User belonging to User Group is able to access
foreman entities as per roles.
@CaseLevel: Integration
"""
self.check_external_user()
strategy, value = locators['login.loggedin']
foreman_role = gen_string('alpha')
location_name = gen_string('alpha')
with Session(self.browser) as session:
make_role(session, name=foreman_role)
self.role.update(
foreman_role,
add_permission=True,
permission_list=PERMISSIONS['Location'],
resource_type='Location',
)
make_usergroup(
session,
name=self.usergroup_name,
roles=[foreman_role],
ext_usergrp='foobargroup',
ext_authsourceid="LDAP-" + self.ldap_server_name,
)
self.assertIsNotNone(self.usergroup.search(self.usergroup_name))
set_context(session, org=ANY_CONTEXT['org'])
self.user.update(
username=self.ldap_user_name,
authorized_by='LDAP-' + self.ldap_server_name,
new_password=self.ldap_user_passwd,
password_confirmation=self.ldap_user_passwd,
)
with Session(
self.browser,
self.ldap_user_name,
self.ldap_user_passwd,
) as session:
self.assertIsNotNone(
self.login.wait_until_element(
(strategy, value % self.ldap_user_name)))
make_loc(session, name=location_name)
self.assertIsNotNone(self.location.search(location_name))
def test_remove_empty_usergroup(self, group_name):
"""@Test: Delete an empty Usergroup
@Feature: Usergroup - Positive Delete
@Assert: Usergroup is deleted
"""
with Session(self.browser) as session:
make_usergroup(
session, org=self.organization.name, name=group_name)
self.usergroup.delete(group_name)
def test_positive_delete_empty(self):
"""Delete an empty Usergroup
@id: ca82f84b-bc5a-4f7d-b70d-9ee3e1b0fffa
@Assert: Usergroup is deleted
"""
with Session(self.browser) as session:
for group_name in generate_strings_list():
with self.subTest(group_name):
make_usergroup(
session, org=self.organization.name, name=group_name)
self.usergroup.delete(group_name)
def test_negative_create_usergroup_2(self, group_name):
"""@Test: Create a new UserGroup with blank and whitespace in name
@Feature: Usergroup - Negative Create
@Assert: Usergroup is not created
"""
with Session(self.browser) as session:
make_usergroup(session, org=self.org_name, name=group_name)
self.assertIsNotNone(self.usergroup.wait_until_element
(common_locators["name_haserror"]))
def test_positive_delete_empty(self):
"""Delete an empty Usergroup
@Feature: Usergroup - Positive Delete
@Assert: Usergroup is deleted
"""
with Session(self.browser) as session:
for group_name in generate_strings_list():
with self.subTest(group_name):
make_usergroup(
session, org=self.organization.name, name=group_name)
self.usergroup.delete(group_name)
def test_positive_delete_empty(self):
"""Delete an empty Usergroup
@Feature: Usergroup - Positive Delete
@Assert: Usergroup is deleted
"""
with Session(self.browser) as session:
for group_name in generate_strings_list():
with self.subTest(group_name):
make_usergroup(session,
org=self.organization.name,
name=group_name)
self.usergroup.delete(group_name)
def test_negative_create_usergroup_with_too_long_name(self, group_name):
"""@Test: Create a new UserGroup with 256 characters in name
@Feature: Usergroup - Negative Create
@Assert: Usergroup is not created
"""
with Session(self.browser) as session:
make_usergroup(
session, org=self.organization.name, name=group_name)
self.assertIsNotNone(self.usergroup.wait_until_element(
common_locators['name_haserror']))
self.assertIsNone(self.usergroup.search(group_name))
def test_positive_add_katello_role(self):
"""Associate katello roles to User Group.
[belonging to external AD User Group.]
@id: aa5e3bf4-cb42-43a4-93ea-a2eea54b847a
@Steps:
1. Create an UserGroup.
2. Assign some foreman roles to UserGroup.
3. Create and associate an External AD UserGroup.
@Assert: Whether a User belonging to User Group is able to access
katello entities as per roles.
@CaseLevel: Integration
"""
self.check_external_user()
katello_role = gen_string('alpha')
org_name = gen_string('alpha')
with Session(self.browser) as session:
make_role(session, name=katello_role)
self.role.update(
katello_role,
add_permission=True,
permission_list=PERMISSIONS['Organization'],
resource_type='Organization',
)
make_usergroup(
session,
name=self.usergroup_name,
roles=[katello_role],
ext_usergrp='foobargroup',
ext_authsourceid='LDAP-' + self.ldap_server_name,
)
self.assertIsNotNone(self.usergroup.search(self.usergroup_name))
set_context(session, org=ANY_CONTEXT['org'])
self.user.update(
username=self.ldap_user_name,
authorized_by='LDAP-' + self.ldap_server_name,
new_password=self.ldap_user_passwd,
password_confirmation=self.ldap_user_passwd,
)
with Session(
self.browser,
self.ldap_user_name,
self.ldap_user_passwd
) as session:
make_org(session, org_name=org_name)
self.assertIsNotNone(self.org.search(org_name))
def test_negative_create_usergroup_2(self, group_name):
"""@Test: Create a new UserGroup with blank and whitespace in name
@Feature: Usergroup - Negative Create
@Assert: Usergroup is not created
"""
with Session(self.browser) as session:
make_usergroup(session, org=self.org_name, name=group_name)
self.assertIsNotNone(
self.usergroup.wait_until_element(
common_locators["name_haserror"]))
def test_positive_delete_empty(self):
"""Delete an empty Usergroup
@id: ca82f84b-bc5a-4f7d-b70d-9ee3e1b0fffa
@Assert: Usergroup is deleted
"""
with Session(self.browser) as session:
for group_name in generate_strings_list():
with self.subTest(group_name):
make_usergroup(session,
org=self.organization.name,
name=group_name)
self.usergroup.delete(group_name)
def test_positive_delete_external_roles(self):
"""Deleted AD UserGroup roles get pushed down to user
@feature: LDAP Authentication - Active directory - update
@setup: delete roles from an AD UserGroup
@steps:
1. Create an UserGroup.
2. Assign some roles to UserGroup.
3. Create an External AD UserGroup as per the UserGroup name in AD.
4. Login to sat6 with the AD user.
5. Unassign some of the existing roles of the UserGroup.
6. Login to sat6 with LDAP user that is part of aforementioned
UserGroup.
@assert: User no longer has access to all deleted functional areas
that were assigned to aforementioned UserGroup.
"""
self.check_external_user()
foreman_role = gen_string("alpha")
with Session(self.browser) as session:
make_role(session, name=foreman_role)
self.role.update(
foreman_role, add_permission=True, permission_list=PERMISSIONS["Location"], resource_type="Location"
)
make_usergroup(
session,
name=self.usergroup_name,
roles=[foreman_role],
ext_usergrp="foobargroup",
ext_authsourceid="LDAP-" + self.ldap_server_name,
)
self.assertIsNotNone(self.usergroup.search(self.usergroup_name))
set_context(session, org=ANY_CONTEXT["org"])
self.user.update(
username=self.ldap_user_name,
authorized_by="LDAP-" + self.ldap_server_name,
password=self.ldap_user_passwd,
)
with Session(self.browser, self.ldap_user_name, self.ldap_user_passwd) as session:
session.nav.go_to_loc()
with Session(self.browser):
self.usergroup.update(self.usergroup_name, roles=[foreman_role], entity_select=False)
with Session(self.browser, self.ldap_user_name, self.ldap_user_passwd) as session:
ActionChains(self.browser).move_to_element(
session.nav.wait_until_element(menu_locators["menu.any_context"])
).perform()
self.assertIsNone(session.nav.wait_until_element(menu_locators["loc.manage_loc"]))
def test_positive_add_katello_role(self):
"""Associate katello roles to User Group.
[belonging to external AD User Group.]
:id: aa5e3bf4-cb42-43a4-93ea-a2eea54b847a
:Steps:
1. Create an UserGroup.
2. Assign some foreman roles to UserGroup.
3. Create and associate an External AD UserGroup.
:expectedresults: Whether a User belonging to User Group is able to
access katello entities as per roles.
:CaseLevel: Integration
"""
self.check_external_user()
katello_role = gen_string('alpha')
org_name = gen_string('alpha')
with Session(self) as session:
make_role(session, name=katello_role)
self.role.add_permission(
katello_role,
permission_list=PERMISSIONS['Organization'],
resource_type='Organization',
)
make_usergroup(
session,
name=self.usergroup_name,
roles=[katello_role],
ext_usergrp='foobargroup',
ext_authsourceid='LDAP-' + self.ldap_server_name,
)
self.assertIsNotNone(self.usergroup.search(self.usergroup_name))
set_context(session, org=ANY_CONTEXT['org'])
self.user.update(
username=self.ldap_user_name,
authorized_by='LDAP-' + self.ldap_server_name,
new_password=self.ldap_user_passwd,
password_confirmation=self.ldap_user_passwd,
)
with Session(
self,
self.ldap_user_name,
self.ldap_user_passwd
) as session:
make_org(session, org_name=org_name)
self.assertIsNotNone(self.org.search(org_name))
def test_negative_create_with_invalid_name(self):
"""Create a new UserGroup with invalid names
@id: 2c67dcd6-89b7-4a04-8528-d1f1f2c4530d
@Assert: Usergroup is not created
"""
with Session(self.browser) as session:
for group_name in invalid_names_list():
with self.subTest(group_name):
make_usergroup(
session, org=self.organization.name, name=group_name)
self.assertIsNotNone(self.usergroup.wait_until_element(
common_locators['name_haserror']))
self.assertIsNone(self.usergroup.search(group_name))
def test_negative_create_usergroup_1(self):
"""@Test: Create a new UserGroup with 256 characters in name
@Feature: Usergroup - Negative Create
@Assert: Usergroup is not created
"""
group_name = StringField(str_type=('alphanumeric',),
len=256).get_value()
with Session(self.browser) as session:
make_usergroup(session, org=self.org_name, name=group_name)
self.assertIsNotNone(self.usergroup.wait_until_element
(common_locators["name_haserror"]))
self.assertIsNone(self.usergroup.search(group_name))
def test_negative_create_usergroup_3(self, group_name):
"""@Test: Create a new UserGroup with same name
@Feature: Usergroup - Negative Create
@Assert: Usergroup cannot be created with existing name
"""
with Session(self.browser) as session:
make_usergroup(session, org=self.org_name, name=group_name)
self.assertIsNotNone(self.usergroup.search(group_name))
make_usergroup(session, org=self.org_name, name=group_name)
self.assertIsNotNone(self.usergroup.wait_until_element
(common_locators["name_haserror"]))
def test_negative_create_with_invalid_name(self):
"""Create a new UserGroup with invalid names
@Feature: Usergroup - Negative Create
@Assert: Usergroup is not created
"""
with Session(self.browser) as session:
for group_name in invalid_values_list(interface='ui'):
with self.subTest(group_name):
make_usergroup(
session, org=self.organization.name, name=group_name)
self.assertIsNotNone(self.usergroup.wait_until_element(
common_locators['name_haserror']))
self.assertIsNone(self.usergroup.search(group_name))
def test_positive_delete_empty(self):
"""Delete an empty Usergroup
:id: ca82f84b-bc5a-4f7d-b70d-9ee3e1b0fffa
:expectedresults: Usergroup is deleted
:CaseImportance: Critical
"""
with Session(self) as session:
for group_name in generate_strings_list():
with self.subTest(group_name):
make_usergroup(
session, org=self.organization.name, name=group_name)
self.usergroup.delete(group_name)
def test_positive_delete_empty(self):
"""Delete an empty Usergroup
:id: ca82f84b-bc5a-4f7d-b70d-9ee3e1b0fffa
:expectedresults: Usergroup is deleted
:CaseImportance: Critical
"""
with Session(self) as session:
for group_name in generate_strings_list():
with self.subTest(group_name):
make_usergroup(
session, org=self.organization.name, name=group_name)
self.usergroup.delete(group_name)
def test_positive_create_with_name(self):
"""Create new Usergroup using different names
@Feature: Usergroup - Positive Create
@Assert: Usergroup is created successfully
"""
user_name = gen_string('alpha')
password = gen_string('alpha')
# Create a new user
entities.User(login=user_name, password=password).create()
with Session(self.browser) as session:
for group_name in generate_strings_list():
with self.subTest(group_name):
make_usergroup(session, name=group_name, users=[user_name])
self.assertIsNotNone(self.usergroup.search(group_name))
def test_positive_create_with_name(self):
"""Create new Usergroup using different names
@Feature: Usergroup - Positive Create
@Assert: Usergroup is created successfully
"""
user_name = gen_string('alpha')
password = gen_string('alpha')
# Create a new user
entities.User(login=user_name, password=password).create()
with Session(self.browser) as session:
for group_name in generate_strings_list():
with self.subTest(group_name):
make_usergroup(session, name=group_name, users=[user_name])
self.assertIsNotNone(self.usergroup.search(group_name))
def test_positive_update_name(self):
"""Update usergroup with new name
@id: 2f49ab7c-2f11-48c0-99c2-448fc86b5ad2
@Assert: Usergroup is updated
"""
name = gen_string('alpha')
with Session(self.browser) as session:
make_usergroup(session, name=name)
self.assertIsNotNone(self.usergroup.search(name))
for new_name in generate_strings_list():
with self.subTest(new_name):
self.usergroup.update(name, new_name)
self.assertIsNotNone(self.usergroup.search(new_name))
name = new_name # for next iteration
def test_negative_create_usergroup_3(self, group_name):
"""@Test: Create a new UserGroup with same name
@Feature: Usergroup - Negative Create
@Assert: Usergroup cannot be created with existing name
"""
with Session(self.browser) as session:
make_usergroup(session, org=self.org_name, name=group_name)
self.assertIsNotNone(self.usergroup.search(group_name))
make_usergroup(session, org=self.org_name, name=group_name)
self.assertIsNotNone(
self.usergroup.wait_until_element(
common_locators["name_haserror"]))
def test_positive_create_usergroup(self, group_name):
"""@Test: Create new Usergroup
@Feature: Usergroup - Positive Create
@Assert: Usergroup is created
"""
user_name = gen_string('alpha')
password = gen_string('alpha')
# Create a new user
entities.User(login=user_name, password=password).create()
with Session(self.browser) as session:
make_usergroup(session, name=group_name, users=[user_name])
self.assertIsNotNone(self.usergroup.search(group_name))
def test_negative_create_with_same_name(self):
"""Create a new UserGroup with same name
@id: 5dafa0d4-e2a2-4ac0-926d-fa57d56bbe0b
@Assert: Usergroup cannot be created with existing name
"""
group_name = gen_string('alphanumeric')
with Session(self.browser) as session:
make_usergroup(
session, org=self.organization.name, name=group_name)
self.assertIsNotNone(self.usergroup.search(group_name))
make_usergroup(
session, org=self.organization.name, name=group_name)
self.assertIsNotNone(self.usergroup.wait_until_element(
common_locators['name_haserror']))
def test_positive_update_name(self):
"""Update usergroup with new name
@id: 2f49ab7c-2f11-48c0-99c2-448fc86b5ad2
@Assert: Usergroup is updated
"""
name = gen_string('alpha')
with Session(self.browser) as session:
make_usergroup(session, name=name)
self.assertIsNotNone(self.usergroup.search(name))
for new_name in generate_strings_list():
with self.subTest(new_name):
self.usergroup.update(name, new_name)
self.assertIsNotNone(self.usergroup.search(new_name))
name = new_name # for next iteration
def test_remove_empty_usergroup(self, group_name):
"""@Test: Delete an empty Usergroup
@Feature: Usergroup - Positive Delete
@Assert: Usergroup is deleted
"""
with Session(self.browser) as session:
make_usergroup(session, org=self.org_name, name=group_name)
self.assertIsNotNone(self.usergroup.search(group_name))
self.usergroup.delete(group_name, True)
self.assertIsNotNone(self.usergroup.wait_until_element
(common_locators["notif.success"]))
self.assertIsNone(self.usergroup.search(group_name))
def test_negative_create_with_invalid_name(self):
"""Create a new UserGroup with invalid names
@Feature: Usergroup - Negative Create
@Assert: Usergroup is not created
"""
with Session(self.browser) as session:
for group_name in invalid_values_list(interface='ui'):
with self.subTest(group_name):
make_usergroup(session,
org=self.organization.name,
name=group_name)
self.assertIsNotNone(
self.usergroup.wait_until_element(
common_locators['name_haserror']))
self.assertIsNone(self.usergroup.search(group_name))
def test_negative_create_usergroup_with_same_name(self):
"""@Test: Create a new UserGroup with same name
@Feature: Usergroup - Negative Create
@Assert: Usergroup cannot be created with existing name
"""
group_name = gen_string('alphanumeric')
with Session(self.browser) as session:
make_usergroup(
session, org=self.organization.name, name=group_name)
self.assertIsNotNone(self.usergroup.search(group_name))
make_usergroup(
session, org=self.organization.name, name=group_name)
self.assertIsNotNone(self.usergroup.wait_until_element(
common_locators['name_haserror']))
def test_adusergroup_katello_role(self):
"""@Test: Associate katello roles to User Group.
[belonging to external AD User Group.]
@Feature: LDAP Authentication - Active Directory - associate katello
roles
@Steps:
1. Create an UserGroup.
2. Assign some foreman roles to UserGroup.
3. create and associate an External AD UserGroup.
@Assert: Whether a User belonging to User Group is able to access
katello entities as per roles.
"""
strategy, value = locators['login.loggedin']
katello_role = gen_string('alpha')
org_name = gen_string('alpha')
with Session(self.browser) as session:
make_role(session, name=katello_role)
self.role.update(
katello_role,
add_permission=True,
permission_list=PERMISSIONS['Organization'],
resource_type='Organization',
)
make_usergroup(
session,
name=self.usergroup_name,
roles=[katello_role],
ext_usergrp='foobargroup',
ext_authsourceid='LDAP-' + self.ldap_server_name,
)
self.assertIsNotNone(self.usergroup.search(self.usergroup_name))
with Session(
self.browser,
self.ldap_user_name,
self.ldap_user_passwd,
) as session:
self.assertIsNotNone(self.login.wait_until_element(
(strategy, value % self.ldap_user_name)
))
make_org(session, org_name=org_name)
self.assertIsNotNone(self.org.search(org_name))
def test_remove_empty_usergroup(self, group_name):
"""@Test: Delete an empty Usergroup
@Feature: Usergroup - Positive Delete
@Assert: Usergroup is deleted
"""
with Session(self.browser) as session:
make_usergroup(session, org=self.org_name, name=group_name)
self.assertIsNotNone(self.usergroup.search(group_name))
self.usergroup.delete(group_name, True)
self.assertIsNotNone(
self.usergroup.wait_until_element(
common_locators["notif.success"]))
self.assertIsNone(self.usergroup.search(group_name))
def test_negative_create_with_invalid_name(self):
"""Create a new UserGroup with invalid names
:id: 2c67dcd6-89b7-4a04-8528-d1f1f2c4530d
:expectedresults: Usergroup is not created
:CaseImportance: Critical
"""
with Session(self) as session:
for group_name in invalid_names_list():
with self.subTest(group_name):
make_usergroup(
session, org=self.organization.name, name=group_name)
self.assertIsNotNone(self.usergroup.wait_until_element(
common_locators['name_haserror']))
self.assertIsNone(self.usergroup.search(group_name))
def test_positive_add_katello_role(self):
"""Associate katello roles to User Group.
[belonging to external AD User Group.]
@Feature: LDAP Authentication - Active Directory - associate katello
roles
@Steps:
1. Create an UserGroup.
2. Assign some foreman roles to UserGroup.
3. create and associate an External AD UserGroup.
@Assert: Whether a User belonging to User Group is able to access
katello entities as per roles.
"""
strategy, value = locators['login.loggedin']
katello_role = gen_string('alpha')
org_name = gen_string('alpha')
with Session(self.browser) as session:
make_role(session, name=katello_role)
self.role.update(
katello_role,
add_permission=True,
permission_list=PERMISSIONS['Organization'],
resource_type='Organization',
)
make_usergroup(
session,
name=self.usergroup_name,
roles=[katello_role],
ext_usergrp='foobargroup',
ext_authsourceid='LDAP-' + self.ldap_server_name,
)
self.assertIsNotNone(self.usergroup.search(self.usergroup_name))
with Session(
self.browser,
self.ldap_user_name,
self.ldap_user_passwd,
) as session:
self.assertIsNotNone(
self.login.wait_until_element(
(strategy, value % self.ldap_user_name)))
make_org(session, org_name=org_name)
self.assertIsNotNone(self.org.search(org_name))
def test_negative_create_with_same_name(self):
"""Create a new UserGroup with same name
:id: 5dafa0d4-e2a2-4ac0-926d-fa57d56bbe0b
:expectedresults: Usergroup cannot be created with existing name
:CaseImportance: Critical
"""
group_name = gen_string('alphanumeric')
with Session(self) as session:
make_usergroup(
session, org=self.organization.name, name=group_name)
self.assertIsNotNone(self.usergroup.search(group_name))
make_usergroup(
session, org=self.organization.name, name=group_name)
self.assertIsNotNone(self.usergroup.wait_until_element(
common_locators['name_haserror']))
def test_positive_update_name(self):
"""Update usergroup with new name
:id: 2f49ab7c-2f11-48c0-99c2-448fc86b5ad2
:expectedresults: Usergroup is updated
:CaseImportance: Critical
"""
name = gen_string('alpha')
with Session(self) as session:
make_usergroup(session, name=name)
self.assertIsNotNone(self.usergroup.search(name))
for new_name in generate_strings_list():
with self.subTest(new_name):
self.usergroup.update(name, new_name)
self.assertIsNotNone(self.usergroup.search(new_name))
name = new_name # for next iteration
def test_positive_update_loc_with_admin_perms(self):
"""Add non-admin user to a usergroup with administrative privileges and
make sure user can update his locations
:id: 03fb44cb-1a15-4eca-93d5-346837055bd0
:BZ: 1390833
:expectedresults: user can update his assigned locations
"""
loc1 = entities.Location().create()
loc2 = entities.Location().create()
password = gen_string('alpha')
user = entities.User(
admin=False,
default_organization=self.organization,
location=[loc1],
organization=[self.organization],
password=password,
).create()
group_name = gen_string('alpha')
# Create a usergroup with admin permissions and associate the user
with Session(self) as session:
make_usergroup(session,
name=group_name,
org=self.organization.name)
self.assertIsNotNone(self.usergroup.search(group_name))
self.usergroup.update(group_name,
users=[user.login],
roles=['admin'])
self.assertIsNotNone(self.usergroup.search(group_name))
# Login as the user and assign new location
with Session(self, user=user.login, password=password):
self.user.update(
user.login,
new_locations=[loc2.name],
)
# Make sure both locations are assigned
self.user.click(self.user.search(user.login))
self.user.click(tab_locators['users.tab_locations'])
for loc in (loc1.name, loc2.name):
self.assertIsNotNone(
self.user.wait_until_element(
common_locators['entity_deselect'] % loc))
def test_update_usergroup(self, test_data):
"""@Test: Update usergroup with name or users
@Feature: Usergroup - Positive Update
@Assert: Usergroup is updated
"""
name = test_data['name']
new_name = test_data['new_name']
user_name = gen_string("alpha", 6)
password = gen_string("alpha", 6)
# Create a new user
entities.User(login=user_name, password=password).create()
with Session(self.browser) as session:
make_usergroup(session, name=name)
self.assertIsNotNone(self.usergroup.search(name))
self.usergroup.update(name, new_name, users=[user_name])
self.assertIsNotNone(self.usergroup.search(new_name))
def test_negative_create_with_same_name(self):
"""Create a new UserGroup with same name
@Feature: Usergroup - Negative Create
@Assert: Usergroup cannot be created with existing name
"""
group_name = gen_string('alphanumeric')
with Session(self.browser) as session:
make_usergroup(session,
org=self.organization.name,
name=group_name)
self.assertIsNotNone(self.usergroup.search(group_name))
make_usergroup(session,
org=self.organization.name,
name=group_name)
self.assertIsNotNone(
self.usergroup.wait_until_element(
common_locators['name_haserror']))
def test_positive_add_admin_role(self):
"""Associate Admin role to User Group. [belonging to external AD User
Group.]
:id: c3371810-1ddc-4a2c-b7e1-3b4d5db3a755
:Steps:
1. Create an UserGroup.
2. Assign admin role to UserGroup.
3. Create and associate an External AD UserGroup.
:expectedresults: Whether a User belonging to User Group is able to
access some of the pages.
:CaseImportance: Critical
"""
self.check_external_user()
with Session(self.browser) as session:
make_usergroup(
session,
name=self.usergroup_name,
roles=['admin'],
ext_usergrp='foobargroup',
ext_authsourceid='LDAP-' + self.ldap_server_name,
)
self.assertIsNotNone(self.usergroup.search(self.usergroup_name))
set_context(session, org=ANY_CONTEXT['org'])
self.user.update(
username=self.ldap_user_name,
authorized_by='LDAP-' + self.ldap_server_name,
new_password=self.ldap_user_passwd,
password_confirmation=self.ldap_user_passwd,
)
with Session(
self.browser,
self.ldap_user_name,
self.ldap_user_passwd,
):
session.nav.go_to_users()
session.nav.go_to_roles()
session.nav.go_to_content_views()
def test_positive_update_org_with_admin_perms(self):
"""Add non-admin user to a usergroup with administrative privileges and
make sure user can update his organizations
:id: 13d50901-d94a-4ede-a134-d7b5e84c9a2c
:BZ: 1390833
:expectedresults: user can update his assigned organizations
"""
new_org = entities.Organization().create()
password = gen_string('alpha')
user = entities.User(
admin=False,
default_organization=self.organization,
password=password,
organization=[self.organization],
).create()
group_name = gen_string('alpha')
# Create a usergroup with admin permissions and associate the user
with Session(self) as session:
make_usergroup(session,
name=group_name,
org=self.organization.name)
self.assertIsNotNone(self.usergroup.search(group_name))
self.usergroup.update(group_name,
users=[user.login],
roles=['admin'])
self.assertIsNotNone(self.usergroup.search(group_name))
# Login as the user and assign new organization
with Session(self, user=user.login, password=password):
self.user.update(
user.login,
new_organizations=[new_org.name],
)
# Make sure both organizations are assigned
self.user.click(self.user.search(user.login))
self.user.click(tab_locators['users.tab_organizations'])
for org in (self.organization.name, new_org.name):
self.assertIsNotNone(
self.user.wait_until_element(
common_locators['entity_deselect'] % org))
def test_positive_create_usergroup(self, group_name):
"""@Test: Create new Usergroup
@Feature: Usergroup - Positive Create
@Assert: Usergroup is created
"""
user_name = gen_string("alpha", 6)
password = gen_string("alpha", 6)
# Create a new user
entities.User(
login=user_name,
password=password,
).create()
with Session(self.browser) as session:
make_usergroup(session, name=group_name, users=[user_name])
self.assertIsNotNone(self.usergroup.search(group_name))
def test_positive_update_user(self):
"""Update usergroup with new user
@id: 5fdb1c36-196d-4ba5-898d-40f484b81090
@Assert: Usergroup is updated
"""
name = gen_string('alpha')
user_name = gen_string('alpha')
# Create a new user
entities.User(
login=user_name,
password=gen_string('alpha'),
organization=[self.organization],
).create()
with Session(self.browser) as session:
make_usergroup(session, name=name, org=self.organization.name)
self.assertIsNotNone(self.usergroup.search(name))
self.usergroup.update(name, users=[user_name])
self.assertIsNotNone(self.usergroup.search(name))
def test_positive_update_name(self):
"""Update usergroup with new name
@Feature: Usergroup - Positive Update
@Assert: Usergroup is updated
"""
name = gen_string('alpha')
user_name = gen_string('alpha')
password = gen_string('alpha')
# Create a new user
entities.User(login=user_name, password=password).create()
with Session(self.browser) as session:
make_usergroup(session, name=name)
self.assertIsNotNone(self.usergroup.search(name))
for new_name in generate_strings_list():
with self.subTest(new_name):
self.usergroup.update(name, new_name, users=[user_name])
self.assertIsNotNone(self.usergroup.search(new_name))
name = new_name # for next iteration
def test_positive_create_external(self):
"""Create External AD User Group as per AD group
@Feature: LDAP Authentication - Active Directory - create
@Steps:
1. Create an UserGroup.
2. Assign some roles to UserGroup.
3. create an External AD UserGroup as per the UserGroup name in AD
@Assert: Whether creation of External AD User Group is possible.
"""
with Session(self.browser) as session:
make_usergroup(
session,
name=self.usergroup_name,
roles=['admin'],
ext_usergrp='foobargroup',
ext_authsourceid='LDAP-' + self.ldap_server_name,
)
self.assertIsNotNone(self.usergroup.search(self.usergroup_name))
def test_negative_create_external_with_invalid_name(self):
"""Create External AD User Group with random name
@Feature: LDAP Authentication - Active Directory - create
@Steps:
1. Create an UserGroup.
2. Assign some roles to UserGroup.
3. create an External AD UserGroup with any random name.
@Assert: Creation of External AD User Group should not be possible with
random name.
"""
with Session(self.browser) as session:
make_usergroup(
session,
name=self.usergroup_name,
roles=['admin'],
ext_usergrp=gen_string('alpha'),
ext_authsourceid='LDAP-' + self.ldap_server_name,
)
self.assertIsNone(self.usergroup.search(self.usergroup_name))
