def module_azurerm_custom_finishimg(default_architecture, default_os, module_azurerm_cr):
""" Creates Custom Finish Template image on AzureRM Compute Resource """
finish_image = entities.Image(
architecture=default_architecture,
compute_resource=module_azurerm_cr,
name=gen_string('alpha'),
operatingsystem=default_os,
username=settings.azurerm.username,
uuid=AZURERM_RHEL7_FT_CUSTOM_IMG_URN,
).create()
return finish_image
def module_gce_finishimg(default_architecture, module_gce_compute, default_os,
gce_latest_rhel_uuid):
"""Creates finish image on GCE Compute Resource"""
finish_image = entities.Image(
architecture=default_architecture,
compute_resource=module_gce_compute,
name=gen_string('alpha'),
operatingsystem=default_os,
username=finishuser,
uuid=gce_latest_rhel_uuid,
).create()
return finish_image
def module_azurerm_cloudimg(default_architecture, default_os, module_azurerm_cr):
""" Creates cloudinit image on AzureRM Compute Resource """
finish_image = entities.Image(
architecture=default_architecture,
compute_resource=module_azurerm_cr,
name=gen_string('alpha'),
operatingsystem=default_os,
username=settings.azurerm.username,
uuid=AZURERM_RHEL7_UD_IMG_URN,
user_data=True,
).create()
return finish_image
def module_gce_cloudimg(default_architecture, module_gce_compute, default_os,
gce_custom_cloudinit_uuid):
"""Creates cloudinit image on GCE Compute Resource"""
cloud_image = entities.Image(
architecture=default_architecture,
compute_resource=module_gce_compute,
name=gen_string('alpha'),
operatingsystem=default_os,
username=clouduser,
uuid=gce_custom_cloudinit_uuid,
user_data=True,
).create()
return cloud_image
def test_pre_create_gce_cr_and_host(self, arch_os_domain, function_org,
gce_cert):
"""Create GCE Compute Resource
:id: preupgrade-ef82143d-efef-49b2-9702-93d67ef6804c
:steps: In Preupgrade Satellite, create GCE Compute Resource
:expectedresults: The GCE CR created successfully
"""
arch, os, domain_name = arch_os_domain
cr_name = gen_string('alpha')
loc = entities.Location().create()
with Session('gce_upgrade_tests') as session:
# Compute Resource Create and Assertions
session.computeresource.create({
'name':
cr_name,
'provider':
FOREMAN_PROVIDERS['google'],
'provider_content.google_project_id':
gce_cert['project_id'],
'provider_content.client_email':
gce_cert['client_email'],
'provider_content.certificate_path':
settings.gce.cert_path,
'provider_content.zone.value':
settings.gce.zone,
'organizations.resources.assigned': [function_org.name],
'locations.resources.assigned': [loc.name],
})
gce_cr = entities.AbstractComputeResource().search(
query={'search': f'name={cr_name}'})[0]
gce_img = entities.Image(
architecture=arch,
compute_resource=gce_cr,
name='autoupgrade_gce_img',
operatingsystem=os,
username='******',
uuid=LATEST_RHEL7_GCE_IMG_UUID,
).create()
create_dict({
self.__class__.__name__: {
'org': function_org.name,
'loc': loc.name,
'cr_name': cr_name,
}
})
assert gce_cr.name == cr_name
assert gce_img.name == 'autoupgrade_gce_img'
def test_pre_create_gce_cr_and_host(self):
"""
"""
cr_name = gen_string('alpha')
org = entities.Organization().create()
loc = entities.Location().create()
with Session('gce_upgrade_tests') as session:
# Compute Resource Create and Assertions
session.computeresource.create({
'name':
cr_name,
'provider':
FOREMAN_PROVIDERS['google'],
'provider_content.google_project_id':
GCE_SETTINGS['project_id'],
'provider_content.client_email':
GCE_SETTINGS['client_email'],
'provider_content.certificate_path':
GCE_SETTINGS['cert_path'],
'provider_content.zone.value':
GCE_SETTINGS['zone'],
'organizations.resources.assigned': [org.name],
'locations.resources.assigned': [loc.name],
})
gce_cr = entities.AbstractComputeResource().search(
query={'search': 'name={}'.format(cr_name)})[0]
gce_img = entities.Image(
architecture=self.arch,
compute_resource=gce_cr,
name='autoupgrade_gce_img',
operatingsystem=self.os,
username='******',
uuid=LATEST_RHEL7_GCE_IMG_UUID,
).create()
create_dict({
self.__class__.__name__: {
'org': org.name,
'loc': loc.name,
'cr_name': cr_name
}
})
assert gce_cr.name == cr_name
assert gce_img.name == 'autoupgrade_gce_img'
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'])
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 module_libvirt_image(module_cr_libvirt):
return entities.Image(compute_resource=module_cr_libvirt).create()
