def create_ldap(self, ad_data):
"""Fetch necessary properties from settings and Create ldap auth source"""
org = entities.Organization().create()
loc = entities.Location(organization=[org]).create()
ad_data = ad_data()
yield dict(
org=org,
loc=loc,
sat_url=f'https://{settings.server.hostname}',
ldap_user_name=ad_data['ldap_user_name'],
ldap_user_passwd=ad_data['ldap_user_passwd'],
authsource=entities.AuthSourceLDAP(
onthefly_register=True,
account=ad_data['ldap_user_name'],
account_password=ad_data['ldap_user_passwd'],
base_dn=ad_data['base_dn'],
groups_base=ad_data['group_base_dn'],
attr_firstname=LDAP_ATTR['firstname'],
attr_lastname=LDAP_ATTR['surname'],
attr_login=LDAP_ATTR['login_ad'],
server_type=LDAP_SERVER_TYPE['API']['ad'],
attr_mail=LDAP_ATTR['mail'],
name=gen_string('alpha'),
host=ad_data['ldap_hostname'],
tls=False,
port='389',
location=[loc],
organization=[org],
).create(),
)
for user in entities.User().search(
query={'search': f'login={ad_data["ldap_user_name"]}'}):
user.delete()
org.delete()
loc.delete()
def test_post_verify_usergroup_membership(request):
"""After upgrade, check the LDAP user's(that we created before the upgrade) existence and
their functionality.
:steps:
1. verify ldap user(created before upgrade) is part of user group.
2. Update ldap auth.
:expectedresults: After upgrade, user group membership should remain the same and LDAP
auth update should work.
"""
pre_test_name = [
mark.kwargs['depend_on'].__name__ for mark in request.node.own_markers
if 'depend_on' in mark.kwargs
][0]
user_group = entities.UserGroup().search(
query={'search': f'name={pre_test_name}_user_group'})
authsource = entities.AuthSourceLDAP().search(
query={'search': f'name={pre_test_name}_server'})[0]
request.addfinalizer(authsource.delete)
request.addfinalizer(user_group[0].delete)
user = entities.User().search(
query={'search': f'login={settings.ldap.username}'})[0]
request.addfinalizer(user.delete)
assert user.read().id == user_group[0].read().user[0].id
def test_post_verify_usergroup_membership(self, request, dependent_scenario_name):
"""After upgrade, check the LDAP user created before the upgrade still exists and its
update functionality should work.
:id: postupgrade-7545fc6a-bd57-4403-90c8-c68a7a3b5bca
:steps:
1. verify ldap user(created before upgrade) is part of user group.
2. Update ldap auth.
:expectedresults: After upgrade, user group membership should remain the same and LDAP
auth update should work.
"""
pre_test_name = dependent_scenario_name
user_group = entities.UserGroup().search(
query={'search': f'name={pre_test_name}_user_group'}
)
authsource = entities.AuthSourceLDAP().search(
query={'search': f'name={pre_test_name}_server'}
)[0]
request.addfinalizer(authsource.delete)
request.addfinalizer(user_group[0].delete)
user = entities.User().search(query={'search': f'login={settings.ldap.username}'})[0]
request.addfinalizer(user.delete)
assert user.read().id == user_group[0].read().user[0].id
def create_ldap(self):
"""Fetch necessary properties from settings and Create ldap auth source"""
org = entities.Organization().create()
loc = entities.Location(organization=[org]).create()
yield dict(
org=org,
loc=loc,
sat_url='https://{}'.format(settings.server.hostname),
ldap_user_name=settings.ldap.username,
ldap_user_passwd=settings.ldap.password,
authsource=entities.AuthSourceLDAP(
onthefly_register=True,
account=settings.ldap.username,
account_password=settings.ldap.password,
base_dn=settings.ldap.basedn,
groups_base=settings.ldap.grpbasedn,
attr_firstname=LDAP_ATTR['firstname'],
attr_lastname=LDAP_ATTR['surname'],
attr_login=LDAP_ATTR['login_ad'],
server_type=LDAP_SERVER_TYPE['API']['ad'],
attr_mail=LDAP_ATTR['mail'],
name=gen_string('alpha'),
host=settings.ldap.hostname,
tls=False,
port='389',
location=[loc],
organization=[org],
).create(),
)
for user in entities.User().search(
query={'search': 'login={}'.format(settings.ldap.username)}):
user.delete()
org.delete()
loc.delete()
def setUpClass(cls): # noqa
super(ActiveDirectoryUserTestCase, cls).setUpClass()
cls.ldap_user_name = settings.ldap.username
cls.ldap_user_passwd = settings.ldap.password
cls.base_dn = settings.ldap.basedn
cls.group_base_dn = settings.ldap.grpbasedn
cls.ldap_hostname = settings.ldap.hostname
cls.usergroup_name = gen_string('alpha')
authsource_attrs = entities.AuthSourceLDAP(
onthefly_register=True,
account=cls.ldap_user_name,
account_password=cls.ldap_user_passwd,
base_dn=cls.base_dn,
groups_base=cls.group_base_dn,
attr_firstname=LDAP_ATTR['firstname'],
attr_lastname=LDAP_ATTR['surname'],
attr_login=LDAP_ATTR['login_ad'],
server_type=LDAP_SERVER_TYPE['API']['ad'],
attr_mail=LDAP_ATTR['mail'],
name=gen_string('alpha'),
host=cls.ldap_hostname,
tls=False,
port='389',
).create()
cls.ldap_server_name = authsource_attrs.name
def setUpClass(cls):
"""Fetch necessary properties from settings and Create ldap auth source"""
super(FreeIPAUserTestCase, cls).setUpClass()
cls.org = entities.Organization().create()
cls.loc = entities.Location(organization=[cls.org]).create()
cls.sat_url = 'https://{}'.format(settings.server.hostname)
cls.username = settings.ipa.user_ipa
cls.ldap_user_name = settings.ipa.username_ipa
cls.ldap_user_passwd = settings.ipa.password_ipa
cls.authsource = entities.AuthSourceLDAP(
onthefly_register=True,
account=cls.ldap_user_name,
account_password=cls.ldap_user_passwd,
base_dn=settings.ipa.basedn_ipa,
groups_base=settings.ipa.grpbasedn_ipa,
attr_firstname=LDAP_ATTR['firstname'],
attr_lastname=LDAP_ATTR['surname'],
attr_login=LDAP_ATTR['login'],
server_type=LDAP_SERVER_TYPE['API']['ipa'],
attr_mail=LDAP_ATTR['mail'],
name=gen_string('alpha'),
host=settings.ipa.hostname_ipa,
tls=False,
port='389',
location=[cls.loc],
organization=[cls.org],
).create()
def ldap_auth_source(request, module_org, module_loc, ad_data, ipa_data):
if request.param.lower() == 'ad':
# entity create with AD settings
entities.AuthSourceLDAP(
onthefly_register=True,
account=ad_data['ldap_user_name'],
account_password=ad_data['ldap_user_passwd'],
base_dn=ad_data['base_dn'],
groups_base=ad_data['group_base_dn'],
attr_firstname=LDAP_ATTR['firstname'],
attr_lastname=LDAP_ATTR['surname'],
attr_login=LDAP_ATTR['login_ad'],
server_type=LDAP_SERVER_TYPE['API']['ad'],
attr_mail=LDAP_ATTR['mail'],
name=gen_string('alpha'),
host=ad_data['ldap_hostname'],
tls=False,
port='389',
organization=[module_org],
location=[module_loc],
).create()
ldap_data = ad_data
elif request.param.lower() == 'ipa':
# entity create with IPA settings
entities.AuthSourceLDAP(
onthefly_register=True,
account=ipa_data['ldap_user_cn'],
account_password=ipa_data['ldap_user_passwd'],
base_dn=ipa_data['base_dn'],
groups_base=ipa_data['group_base_dn'],
attr_firstname=LDAP_ATTR['firstname'],
attr_lastname=LDAP_ATTR['surname'],
attr_login=LDAP_ATTR['login'],
server_type=LDAP_SERVER_TYPE['API']['ipa'],
attr_mail=LDAP_ATTR['mail'],
name=gen_string('alpha'),
host=ipa_data['ldap_hostname'],
tls=False,
port='389',
organization=[module_org],
location=[module_loc],
).create()
ldap_data = ipa_data
else:
# default auth server settings
raise Exception('Incorrect auth source parameter used')
yield ldap_data
def ldap_auth_name():
"""Return some random ldap name, and attempt to delete all ldap when test starts.
"""
ldap = entities.AuthSourceLDAP().search()
for ldap_auth in range(len(ldap)):
ldap[ldap_auth].delete()
ldap_name = gen_string('alphanumeric')
yield ldap_name
def ldap_tear_down():
"""Teardown the all ldap settings user, usergroup and ldap delete"""
yield
ldap_auth_sources = entities.AuthSourceLDAP().search()
for ldap_auth in ldap_auth_sources:
users = entities.User(auth_source=ldap_auth).search()
for user in users:
user.delete()
ldap_auth.delete()
def _clean_up_previous_ldap(self):
"""clean up the all ldap settings user, usergroup and ldap delete"""
ldap = entities.AuthSourceLDAP().search()
for ldap_auth in range(len(ldap)):
users = entities.User(auth_source=ldap[ldap_auth]).search()
for user in range(len(users)):
users[user].delete()
ldap[ldap_auth].delete()
user_groups = entities.UserGroup().search()
for user_group in user_groups:
user_group.delete()
def test_positive_endtoend(auth_source_type, module_org, module_location,
ad_data, ipa_data):
"""Create/update/delete LDAP authentication with AD using names of different types
:id: e3607c97-7c48-4cf6-b119-2bfd895d9325
:expectedresults: Whether creating/updating/deleting LDAP Auth with AD/IPA is successful.
:parametrized: yes
:CaseImportance: Critical
"""
for server_name in generate_strings_list():
if auth_source_type == 'AD':
auth_source_data = ad_data()
auth_type_attr = LDAP_ATTR[f'login_{auth_source_type.lower()}']
elif auth_source_type == 'IPA':
auth_source_data = ipa_data
auth_source_data['ldap_user_name'] = auth_source_data[
'ldap_user_cn']
auth_type_attr = LDAP_ATTR['login']
authsource = entities.AuthSourceLDAP(
onthefly_register=True,
account=auth_source_data['ldap_user_cn'],
account_password=auth_source_data['ldap_user_passwd'],
base_dn=auth_source_data['base_dn'],
groups_base=auth_source_data['group_base_dn'],
attr_firstname=LDAP_ATTR['firstname'],
attr_lastname=LDAP_ATTR['surname'],
attr_login=auth_type_attr,
server_type=LDAP_SERVER_TYPE['API'][auth_source_type.lower()],
attr_mail=LDAP_ATTR['mail'],
name=server_name,
host=auth_source_data['ldap_hostname'],
tls=False,
port='389',
organization=[module_org],
location=[module_location],
).create()
assert authsource.name == server_name
for new_name in generate_strings_list():
authsource.name = new_name
authsource = authsource.update(['name'])
assert authsource.name == new_name
authsource.delete()
with pytest.raises(HTTPError):
authsource.read()
def auth_source_open_ldap(module_org, module_loc, open_ldap_data):
return entities.AuthSourceLDAP(
onthefly_register=True,
account=open_ldap_data.username,
account_password=open_ldap_data.password,
base_dn=open_ldap_data.base_dn,
attr_firstname=LDAP_ATTR['firstname'],
attr_lastname=LDAP_ATTR['surname'],
attr_login=LDAP_ATTR['login'],
server_type=LDAP_SERVER_TYPE['API']['posix'],
attr_mail=LDAP_ATTR['mail'],
name=gen_string('alpha'),
host=open_ldap_data.hostname,
tls=False,
port='389',
organization=[module_org],
location=[module_loc],
).create()
def test_pre_create_usergroup_with_ldap_user(self, request):
"""Create Usergroup in preupgrade version.
:id: preupgrade-4b11d883-f523-4f38-b65a-650ecd90335c
:steps:
1. Create ldap auth pre upgrade.
2. Login with ldap User in satellite and logout.
3. Create usergroup and assign ldap user to it.
:expectedresults: The usergroup, with ldap user as member, should be created successfully.
"""
authsource = entities.AuthSourceLDAP(
onthefly_register=True,
account=settings.ldap.username,
account_password=settings.ldap.password,
base_dn=settings.ldap.basedn,
groups_base=settings.ldap.grpbasedn,
attr_firstname=LDAP_ATTR['firstname'],
attr_lastname=LDAP_ATTR['surname'],
attr_login=LDAP_ATTR['login_ad'],
server_type=LDAP_SERVER_TYPE['API']['ad'],
attr_mail=LDAP_ATTR['mail'],
name=request.node.name + "_server",
host=settings.ldap.hostname,
tls=False,
port='389',
).create()
assert authsource.name == request.node.name + "_server"
sc = ServerConfig(
auth=(settings.ldap.username, settings.ldap.password),
url=f'https://{settings.server.hostname}',
verify=False,
)
with pytest.raises(HTTPError):
entities.User(sc).search()
user_group = entities.UserGroup(name=request.node.name +
"_user_group").create()
user = entities.User().search(
query={'search': f'login={settings.ldap.username}'})[0]
user_group.user = [user]
user_group = user_group.update(['user'])
assert user.login == user_group.user[0].read().login
def auth_source_ipa(module_org, module_location, ipa_data):
return entities.AuthSourceLDAP(
onthefly_register=True,
account=ipa_data['ldap_user_cn'],
account_password=ipa_data['ldap_user_passwd'],
base_dn=ipa_data['base_dn'],
groups_base=ipa_data['group_base_dn'],
attr_firstname=LDAP_ATTR['firstname'],
attr_lastname=LDAP_ATTR['surname'],
attr_login=LDAP_ATTR['login'],
server_type=LDAP_SERVER_TYPE['API']['ipa'],
attr_mail=LDAP_ATTR['mail'],
name=gen_string('alpha'),
host=ipa_data['ldap_hostname'],
tls=False,
port='389',
organization=[module_org],
location=[module_location],
).create()
def test_pre_create_usergroup_with_ldap_user(self):
"""Create Usergroup in preupgrade version.
:steps:
1. Create ldap auth pre upgrade.
2. Login with ldap User in satellite and logout.
3. Create usergroup and assign ldap user to it.
:expectedresults: The usergroup, with ldap user as member, should be created successfully.
"""
authsource = entities.AuthSourceLDAP(
onthefly_register=True,
account=self.ldap_user_name,
account_password=self.ldap_user_passwd,
base_dn=self.base_dn,
groups_base=self.group_base_dn,
attr_firstname=LDAP_ATTR['firstname'],
attr_lastname=LDAP_ATTR['surname'],
attr_login=LDAP_ATTR['login_ad'],
server_type=LDAP_SERVER_TYPE['API']['ad'],
attr_mail=LDAP_ATTR['mail'],
name=self.server_name,
host=self.ldap_hostname,
tls=False,
port='389',
).create()
self.assertEqual(authsource.name, self.server_name)
sc = ServerConfig(auth=(self.ldap_user_name, self.ldap_user_passwd),
url=self.sat_url,
verify=False)
with self.assertRaises(HTTPError):
entities.User(sc).search()
user_group = entities.UserGroup(
name=self.preupgrade_usergroup).create()
user = entities.User().search(
query={'search': 'login={}'.format(self.ldap_user_name)})[0]
user_group.user = [user]
user_group = user_group.update(['user'])
self.assertEqual(user.login, user_group.user[0].read().login)
def test_positive_endtoend_withad(self):
"""Create/update/delete LDAP authentication with AD using names of different types
:id: e3607c97-7c48-4cf6-b119-2bfd895d9325
:expectedresults: Whether creating/updating/deleting LDAP Auth with AD is successful.
:CaseImportance: Critical
"""
for server_name in generate_strings_list():
with self.subTest(server_name):
authsource = entities.AuthSourceLDAP(
onthefly_register=True,
account=self.ldap_user_name,
account_password=self.ldap_user_passwd,
base_dn=self.base_dn,
groups_base=self.group_base_dn,
attr_firstname=LDAP_ATTR['firstname'],
attr_lastname=LDAP_ATTR['surname'],
attr_login=LDAP_ATTR['login_ad'],
server_type=LDAP_SERVER_TYPE['API']['ad'],
attr_mail=LDAP_ATTR['mail'],
name=server_name,
host=self.ldap_hostname,
tls=False,
port='389',
location=[self.loc],
organization=[self.org],
).create()
self.assertEqual(authsource.name, server_name)
for new_name in generate_strings_list():
with self.subTest(new_name):
authsource.name = new_name
authsource = authsource.update(['name'])
self.assertEqual(authsource.name, new_name)
authsource.delete()
with self.assertRaises(HTTPError):
authsource.read()
def ldap_auth_source(request, module_org, module_location, ad_data, ipa_data,
open_ldap_data):
auth_type = request.param.lower()
if 'ad' in auth_type:
ad_data = ad_data('2019') if '2019' in auth_type else ad_data()
# entity create with AD settings
auth_source = entities.AuthSourceLDAP(
onthefly_register=True,
account=ad_data['ldap_user_name'],
account_password=ad_data['ldap_user_passwd'],
base_dn=ad_data['base_dn'],
groups_base=ad_data['group_base_dn'],
attr_firstname=LDAP_ATTR['firstname'],
attr_lastname=LDAP_ATTR['surname'],
attr_login=LDAP_ATTR['login_ad'],
server_type=LDAP_SERVER_TYPE['API']['ad'],
attr_mail=LDAP_ATTR['mail'],
name=gen_string('alpha'),
host=ad_data['ldap_hostname'],
tls=False,
port='389',
organization=[module_org],
location=[module_location],
).create()
ldap_data = ad_data
elif auth_type == 'ipa':
# entity create with IPA settings
auth_source = entities.AuthSourceLDAP(
onthefly_register=True,
account=ipa_data['ldap_user_cn'],
account_password=ipa_data['ldap_user_passwd'],
base_dn=ipa_data['base_dn'],
groups_base=ipa_data['group_base_dn'],
attr_firstname=LDAP_ATTR['firstname'],
attr_lastname=LDAP_ATTR['surname'],
attr_login=LDAP_ATTR['login'],
server_type=LDAP_SERVER_TYPE['API']['ipa'],
attr_mail=LDAP_ATTR['mail'],
name=gen_string('alpha'),
host=ipa_data['ldap_hostname'],
tls=False,
port='389',
organization=[module_org],
location=[module_location],
).create()
ldap_data = ipa_data
elif auth_type == 'openldap':
# entity create with OpenLdap settings
auth_source = entities.AuthSourceLDAP(
onthefly_register=True,
account=open_ldap_data['ldap_user_cn'],
account_password=open_ldap_data['ldap_user_passwd'],
base_dn=open_ldap_data['base_dn'],
groups_base=open_ldap_data['group_base_dn'],
attr_firstname=LDAP_ATTR['firstname'],
attr_lastname=LDAP_ATTR['surname'],
attr_login=LDAP_ATTR['login'],
server_type=LDAP_SERVER_TYPE['API']['posix'],
attr_mail=LDAP_ATTR['mail'],
name=gen_string('alpha'),
host=open_ldap_data['ldap_hostname'],
tls=False,
port='389',
organization=[module_org],
location=[module_location],
).create()
ldap_data = open_ldap_data
else:
raise Exception('Incorrect auth source parameter used')
ldap_data['auth_type'] = auth_type
if ldap_data['auth_type'] == 'ipa':
ldap_data['server_type'] = LDAP_SERVER_TYPE['UI']['ipa']
ldap_data['attr_login'] = LDAP_ATTR['login']
elif ldap_data['auth_type'] == 'ad':
ldap_data['server_type'] = LDAP_SERVER_TYPE['UI']['ad']
ldap_data['attr_login'] = LDAP_ATTR['login_ad']
else:
ldap_data['server_type'] = LDAP_SERVER_TYPE['UI']['posix']
ldap_data['attr_login'] = LDAP_ATTR['login']
yield ldap_data, auth_source
def test_positive_create_by_type(self):
"""Create entities of different types and check audit logs for these
events using entity type as search criteria
:id: 6c7ea7fc-6728-447f-9655-26fe0a2881bc
:customerscenario: true
:expectedresults: Audit logs contain corresponding entries per each
create event
:BZ: 1426742, 1492668, 1492696
:CaseImportance: Critical
"""
for entity_item in [
{'entity': entities.Architecture()},
{
'entity': entities.AuthSourceLDAP(),
'entity_type': 'auth_source',
'value_template': 'LDAP-{entity.name}'
},
{
'entity': entities.ComputeProfile(),
'entity_type': 'compute_profile'
},
{
'entity': entities.LibvirtComputeResource(),
'entity_type': 'compute_resource',
'value_template': '{entity.name} (Libvirt)'
},
{'entity': entities.ConfigGroup(), 'entity_type': 'config_group'},
{'entity': entities.Domain()},
{'entity': entities.Host()},
{'entity': entities.HostGroup()},
{'entity': entities.Image(
compute_resource=entities.LibvirtComputeResource().create())},
{'entity': entities.Location()},
{'entity': entities.Media(), 'entity_type': 'medium'},
{'entity': entities.Organization()},
{
'entity': entities.OperatingSystem(),
'entity_type': 'os',
'value_template': '{entity.name} {entity.major}'
},
{
'entity': entities.PartitionTable(),
'entity_type': 'ptable',
},
{'entity': entities.PuppetClass()},
{'entity': entities.Role()},
{
'entity': entities.Subnet(),
'value_template': '{entity.name} '
'({entity.network}/{entity.cidr})'
},
{
'entity': entities.ProvisioningTemplate(),
'entity_type': 'template',
},
{'entity': entities.User(), 'value_template': '{entity.login}'},
{'entity': entities.UserGroup()},
]:
created_entity = entity_item['entity'].create()
entity_type = entity_item.get(
'entity_type', created_entity.__class__.__name__.lower())
value_template = entity_item.get('value_template', '{entity.name}')
entity_value = value_template.format(entity=created_entity)
audits = entities.Audit().search(
query={'search': 'type={0}'.format(entity_type)})
entity_audits = [entry for entry in audits
if entry.auditable_name == entity_value]
if not entity_audits:
self.fail('audit not found by name "{}"'.format(entity_value))
audit = entity_audits[0]
self.assertEqual(audit.auditable_id, created_entity.id)
self.assertEqual(audit.action, 'create')
self.assertEqual(audit.version, 1)
def test_positive_create_by_type():
"""Create entities of different types and check audit logs for these
events using entity type as search criteria
:id: 6c7ea7fc-6728-447f-9655-26fe0a2881bc
:customerscenario: true
:expectedresults: Audit logs contain corresponding entries per each
create event
:BZ: 1426742, 1492668, 1492696
:CaseImportance: Medium
"""
for entity_item in [
{
'entity': entities.Architecture()
},
{
'entity': entities.AuthSourceLDAP(),
'entity_type': 'auth_source',
'value_template': 'LDAP-{entity.name}',
},
{
'entity': entities.ComputeProfile(),
'entity_type': 'compute_profile'
},
{
'entity': entities.LibvirtComputeResource(),
'entity_type': 'compute_resource',
'value_template': '{entity.name} (Libvirt)',
},
{
'entity': entities.ConfigGroup(),
'entity_type': 'config_group'
},
{
'entity': entities.Domain()
},
{
'entity': entities.Host()
},
{
'entity': entities.HostGroup()
},
{
'entity':
entities.Image(
compute_resource=entities.LibvirtComputeResource().create())
},
{
'entity': entities.Location()
},
{
'entity': entities.Media(),
'entity_type': 'medium'
},
{
'entity': entities.Organization()
},
{
'entity': entities.OperatingSystem(),
'entity_type': 'os',
'value_template': '{entity.name} {entity.major}',
},
{
'entity': entities.PartitionTable(),
'entity_type': 'ptable'
},
{
'entity': entities.PuppetClass()
},
{
'entity': entities.Role()
},
{
'entity': entities.Subnet(),
'value_template': '{entity.name} ({entity.network}/{entity.cidr})',
},
{
'entity': entities.ProvisioningTemplate(),
'entity_type': 'provisioning_template'
},
{
'entity': entities.User(),
'value_template': '{entity.login}'
},
{
'entity': entities.UserGroup()
},
{
'entity': entities.ContentView(),
'entity_type': 'katello/content_view'
},
{
'entity': entities.LifecycleEnvironment(),
'entity_type': 'katello/kt_environment'
},
{
'entity': entities.ActivationKey(),
'entity_type': 'katello/activation_key'
},
{
'entity': entities.HostCollection(),
'entity_type': 'katello/host_collection'
},
{
'entity': entities.Product(),
'entity_type': 'katello/product'
},
{
'entity': entities.GPGKey(),
'entity_type': 'katello/gpg_key',
'value_template': 'content credential (gpg_key - {entity.name})',
},
{
'entity':
entities.SyncPlan(organization=entities.Organization(id=1)),
'entity_type': 'katello/sync_plan',
},
]:
created_entity = entity_item['entity'].create()
entity_type = entity_item.get(
'entity_type', created_entity.__class__.__name__.lower())
value_template = entity_item.get('value_template', '{entity.name}')
entity_value = value_template.format(entity=created_entity)
audits = entities.Audit().search(
query={'search': f'type={entity_type}'})
entity_audits = [
entry for entry in audits if entry.auditable_name == entity_value
]
assert entity_audits, (
f'audit not found by name "{entity_value}" for entity: '
f'{created_entity.__class__.__name__.lower()}')
audit = entity_audits[0]
assert audit.auditable_id == created_entity.id
assert audit.action == 'create'
assert audit.version == 1
def test_positive_create_by_type(self):
"""Create entities of different types and check audit logs for these
events using entity type and performed action as search criteria
:id: 26197b39-4d56-4aab-8df8-f0fcedbffdb7
:expectedresults: Audit logs contain corresponding entries per each
create event
:CaseImportance: Critical
"""
with Session(self):
for entity_item in [
{
'entity': entities.Architecture(),
'entity_type': 'architecture'
},
{
'entity': entities.AuthSourceLDAP(),
'entity_type': 'auth_source',
'value_template': 'LDAP-{entity.name}'
},
{
'entity': entities.ComputeProfile(),
'entity_type': 'compute_profile'
},
{
'entity': entities.LibvirtComputeResource(),
'entity_type': 'compute_resource',
'value_template': '{entity.name} (Libvirt)'
},
{
'entity': entities.ConfigGroup(),
'entity_type': 'config_group'
},
{
'entity': entities.Domain(),
'entity_type': 'domain'
},
{
'entity': entities.Host(),
'entity_type': 'host'
},
{
'entity': entities.HostGroup(),
'entity_type': 'hostgroup'
},
{
'entity':
entities.Image(compute_resource=entities.
LibvirtComputeResource().create()),
'entity_type':
'image'
},
{
'entity': entities.Location(),
'entity_type': 'location'
},
{
'entity': entities.Media(),
'entity_type': 'medium',
'custom_operation': 'added',
},
{
'entity': entities.Organization(),
'entity_type': 'organization'
},
{
'entity': entities.OperatingSystem(),
'entity_type': 'os',
'value_template': '{entity.name} {entity.major}'
},
{
'entity': entities.PartitionTable(),
'entity_type': 'ptable',
},
{
'entity': entities.PuppetClass(),
'entity_type': 'puppetclass'
},
{
'entity': entities.Role(),
'entity_type': 'role'
},
{
'entity':
entities.Subnet(),
'entity_type':
'subnet',
'value_template':
'{entity.name} '
'({entity.network}/{entity.cidr})'
},
{
'entity': entities.ProvisioningTemplate(),
'entity_type': 'template',
},
{
'entity': entities.User(),
'value_template': '{entity.login}',
'entity_type': 'user',
},
{
'entity': entities.UserGroup(),
'entity_type': 'usergroup'
},
]:
created_entity = entity_item['entity'].create()
value_template = entity_item.get('value_template',
'{entity.name}')
operation_type = entity_item.get('custom_operation', 'created')
entity_value = value_template.format(entity=created_entity)
self.audit.filter('type={} and action=create'.format(
entity_item['entity_type']))
result = self.audit.get_last_entry()
self.assertIn(operation_type, result['full_statement'])
self.assertEqual(entity_value, result['entity_name'])
