def setUpClass(cls):
"""Import some parametrized puppet classes. This is required to make
sure that we have data to be able to perform interactions with smart
class variables.
"""
super(SmartVariablesTestCase, cls).setUpClass()
cls.puppet_modules = [
{
'author': 'robottelo',
'name': 'api_test_variables'
},
]
cls.org = entities.Organization().create()
cv = publish_puppet_module(cls.puppet_modules, CUSTOM_PUPPET_REPO,
cls.org)
cls.env = entities.Environment().search(
query={'search': u'content_view="{0}"'.format(cv.name)})[0]
# Find imported puppet class
cls.puppet_class = entities.PuppetClass().search(
query={
'search':
u'name = "{0}" and environment = "{1}"'.format(
cls.puppet_modules[0]['name'], cls.env.name)
})[0]
# And all its subclasses
cls.puppet_subclasses = entities.PuppetClass().search(
query={
'search':
u'name ~ "{0}::" and environment = "{1}"'.format(
cls.puppet_modules[0]['name'], cls.env.name)
})
def setUpClass(cls):
"""Import some parametrized puppet classes. This is required to make
sure that we have smart class parameter available.
Read all available smart class parameters for imported puppet class to
be able to work with unique entity for each specific test.
"""
super(SmartClassParametersTestCase, cls).setUpClass()
cls.pm_name = 'ui_test_classparameters'
cls.puppet_modules = [
{'author': 'robottelo', 'name': cls.pm_name},
]
cv = publish_puppet_module(
cls.puppet_modules, CUSTOM_PUPPET_REPO, cls.session_org)
cls.env = entities.Environment().search(
query={'search': u'content_view="{0}"'.format(cv.name)}
)[0].read()
cls.puppet_class = entities.PuppetClass().search(query={
'search': u'name = "{0}" and environment = "{1}"'.format(
cls.puppet_modules[0]['name'], cls.env.name)
})[0]
cls.sc_params_list = entities.SmartClassParameters().search(
query={
'search': 'puppetclass="{0}"'.format(cls.puppet_class.name),
'per_page': 1000
})
cls.host = entities.Host(organization=cls.session_org).create()
cls.host.environment = cls.env
cls.host.update(['environment'])
cls.host.add_puppetclass(data={'puppetclass_id': cls.puppet_class.id})
cls.domain_name = entities.Domain(id=cls.host.domain.id).read().name
def test_positive_update_variable_puppet_class(self):
"""Update Smart Variable's puppet class.
:id: 2312cb28-c3b0-4fbc-84cf-b66f0c0c64f0
:steps:
1. Create a smart variable with valid name.
2. Update the puppet class associated to the smart variable created
in step1.
:expectedresults: The variable is updated with new puppet class.
:bz: 1375857
:CaseImportance: Critical
"""
smart_variable = entities.SmartVariable(
puppetclass=self.puppet_class,
).create()
self.assertEqual(smart_variable.puppetclass.id, self.puppet_class.id)
new_puppet = entities.PuppetClass().search(query={
'search': 'name="{0}"'.format(choice(self.puppet_subclasses).name)
})[0]
smart_variable.puppetclass = new_puppet
updated_sv = smart_variable.update(['puppetclass'])
self.assertEqual(updated_sv.puppetclass.id, new_puppet.id)
def setupScenario(self):
"""Import some parametrized puppet classes. This is required to make
sure that we have smart class variable available.
Read all available smart class parameters for imported puppet class to
be able to work with unique entity for each specific test.
"""
self.puppet_modules = [{
'author': 'robottelo',
'name': 'api_test_classparameters'
}]
self.org = entities.Organization().create()
cv = publish_puppet_module(self.puppet_modules, CUSTOM_PUPPET_REPO,
self.org)
self.env = (entities.Environment().search(
query={'search': 'content_view="{0}"'.format(cv.name)})[0].read())
self.puppet_class = entities.PuppetClass().search(
query={
'search':
'name = "{0}" and environment = "{1}"'.format(
self.puppet_modules[0]['name'], self.env.name)
})[0]
self.sc_params_list = entities.SmartClassParameters().search(
query={
'search': 'puppetclass="{0}"'.format(self.puppet_class.name),
'per_page': 1000
})
scenario_ents = {
self.__class__.__name__: {
'puppet_class': self.puppet_class.name
}
}
create_dict(scenario_ents)
def setUpClass(cls):
"""Import some parametrized puppet classes. This is required to make
sure that we have smart class variable available.
Read all available smart class parameters for imported puppet class to
be able to work with unique entity for each specific test.
"""
super(SmartClassParametersTestCase, cls).setUpClass()
cls.puppet_modules = [
{'author': 'robottelo', 'name': 'api_test_classparameters'},
]
cls.org = entities.Organization().create()
cv = publish_puppet_module(
cls.puppet_modules, CUSTOM_PUPPET_REPO, cls.org)
cls.env = entities.Environment().search(
query={'search': u'content_view="{0}"'.format(cv.name)}
)[0].read()
cls.puppet_class = entities.PuppetClass().search(query={
'search': u'name = "{0}" and environment = "{1}"'.format(
cls.puppet_modules[0]['name'], cls.env.name)
})[0]
cls.sc_params_list = entities.SmartClassParameters().search(
query={
'search': 'puppetclass="{0}"'.format(cls.puppet_class.name),
'per_page': 1000
})
def puppet_subclasses(puppet_env):
return entities.PuppetClass().search(
query={
'search':
u'name ~ "{0}::" and environment = "{1}"'.format(
PUPPET_MODULES[0]['name'], puppet_env.name)
})
def puppet_class(puppet_env):
puppet_class_entity = entities.PuppetClass().search(
query={
'search': f'name = "{PUPPET_MODULES[0]["name"]}" and environment = "{puppet_env.name}"'
}
)[0]
yield puppet_class_entity
delete_puppet_class(puppet_class_entity.name)
def module_puppet_classes(module_env_search):
"""Returns puppet class based on following criteria:
Puppet environment from module_env_search and puppet class name. The name was set inside
module_cv_with_puppet_module.
"""
return entities.PuppetClass().search(
query={'search': f'name ~ {"generic_1"} and environment = {module_env_search.name}'}
)
def setUpClass(cls):
"""Import some parametrized puppet classes. This is required to make
sure that we have data to be able to perform interactions with smart
class variables.
"""
super(SmartVariablesTestCase, cls).setUpClass()
cls.puppet_modules = [
{
'author': 'robottelo',
'name': 'ui_test_variables'
},
]
cv = publish_puppet_module(cls.puppet_modules, CUSTOM_PUPPET_REPO,
cls.session_org)
cls.env = entities.Environment().search(
query={'search': u'content_view="{0}"'.format(cv.name)})[0]
# Find imported puppet class
cls.puppet_class = entities.PuppetClass().search(
query={
'search':
u'name = "{0}" and environment = "{1}"'.format(
cls.puppet_modules[0]['name'], cls.env.name)
})[0]
# And all its subclasses
cls.puppet_subclasses = entities.PuppetClass().search(
query={
'search':
u'name ~ "{0}::" and environment = "{1}"'.format(
cls.puppet_modules[0]['name'], cls.env.name)
})
lce = entities.LifecycleEnvironment().search(
query={
'search':
'organization_id="{0}" and name="{1}"'.format(
cls.session_org.id, ENVIRONMENT)
})[0]
cls.host = entities.Host(organization=cls.session_org,
content_facet_attributes={
'content_view_id': cv.id,
'lifecycle_environment_id': lce.id,
}).create()
cls.host.environment = cls.env
cls.host.update(['environment'])
cls.host.add_puppetclass(data={'puppetclass_id': cls.puppet_class.id})
cls.domain_name = entities.Domain(id=cls.host.domain.id).read().name
def delete_puppet_class(puppetclass_name, puppet_module=None,
proxy_hostname=None, environment_name=None):
"""Removes puppet class entity and uninstall puppet module from Capsule if
puppet module name and Capsule details provided.
:param str puppetclass_name: Name of the puppet class entity that should be
removed.
:param str puppet_module: Name of the module that should be
uninstalled via puppet.
:param str proxy_hostname: Hostname of the Capsule from which puppet module
should be removed.
:param str environment_name: Name of environment where puppet module was
imported.
"""
# Find puppet class
puppet_classes = entities.PuppetClass().search(
query={'search': 'name = "{0}"'.format(puppetclass_name)}
)
# And all subclasses
puppet_classes.extend(entities.PuppetClass().search(
query={'search': 'name ~ "{0}::"'.format(puppetclass_name)})
)
for puppet_class in puppet_classes:
# Search and remove puppet class from affected hostgroups
for hostgroup in puppet_class.read().hostgroup:
hostgroup.delete_puppetclass(
data={'puppetclass_id': puppet_class.id}
)
# Search and remove puppet class from affected hosts
for host in entities.Host().search(
query={'search': 'class={0}'.format(puppet_class.name)}):
host.delete_puppetclass(
data={'puppetclass_id': puppet_class.id}
)
# Remove puppet class entity
puppet_class.delete()
# And remove puppet module from the system if puppet_module name provided
if puppet_module and proxy_hostname and environment_name:
ssh.command(
'puppet module uninstall --force {0}'.format(puppet_module))
env = entities.Environment().search(
query={'search': 'name="{0}"'.format(environment_name)}
)[0]
proxy = entities.SmartProxy(name=proxy_hostname).search()[0]
proxy.import_puppetclasses(environment=env)
def puppet_class(puppet_env):
puppet_class_entity = entities.PuppetClass().search(
query={
'search':
'name = "{0}" and environment = "{1}"'.format(
PUPPET_MODULES[0]['name'], puppet_env.name)
})[0]
yield puppet_class_entity
delete_puppet_class(puppet_class_entity.name)
def module_puppet_classes(module_env_search, module_import_puppet_module):
"""Returns puppet class based on following criteria:
Puppet environment from module_env_search and puppet class name.
"""
return entities.PuppetClass().search(
query={
'search':
f'name ~ {module_import_puppet_module["puppet_class"]} '
f'and environment = {module_env_search.name}'
})
def puppet_class(puppet_env):
puppet_class_entity = entities.PuppetClass().search(query={
'search': u'name = "{0}" and environment = "{1}"'.format(
PUPPET_MODULES[0]['name'], puppet_env.name)})[0]
# We need to have at least one variable created to unblock WebUI for Smart
# Variable interface page
if len(entities.SmartVariable(
puppetclass=puppet_class_entity).search({'puppetclass'})) == 0:
entities.SmartVariable(puppetclass=puppet_class_entity).create()
return puppet_class_entity
def test_positive_delete(self):
"""Create new puppet-class and then delete it
@Feature: Puppet-Classes - Positive delete
@Assert: Puppet-Class is deleted successfully.
"""
with Session(self.browser):
for name in valid_data_list():
with self.subTest(name):
entities.PuppetClass(name=name).create()
self.puppetclasses.delete(name)
def test_positive_delete(self):
"""Create new puppet-class and then delete it
@id: 0d6e579e-8a7a-46a1-9932-5f345905671d
@Assert: Puppet-Class is deleted successfully.
"""
with Session(self.browser):
for name in valid_data_list():
with self.subTest(name):
entities.PuppetClass(name=name).create()
self.puppetclasses.delete(name)
def module_puppet():
puppet_modules = [{'author': 'robottelo', 'name': 'api_test_classparameters'}]
org = entities.Organization().create()
cv = publish_puppet_module(puppet_modules, CUSTOM_PUPPET_REPO, org)
env = entities.Environment().search(query={'search': f'content_view="{cv.name}"'})[0].read()
puppet_class = entities.PuppetClass().search(
query={'search': f'name = "{puppet_modules[0]["name"]}" and environment = "{env.name}"'}
)[0]
sc_params_list = entities.SmartClassParameters().search(
query={'search': f'puppetclass="{puppet_class.name}"', 'per_page': '1000'}
)
yield {'env': env, 'class': puppet_class, 'sc_params': sc_params_list}
delete_puppet_class(puppet_class.name)
def test_positive_delete(self):
"""Create new puppet-class and then delete it
:id: 0d6e579e-8a7a-46a1-9932-5f345905671d
:expectedresults: Puppet-Class is deleted successfully.
:CaseImportance: Critical
"""
with Session(self.browser):
for name in valid_data_list():
with self.subTest(name):
entities.PuppetClass(name=name).create()
self.puppetclasses.delete(name)
def module_puppet(default_sat):
puppet_class = 'api_test_classparameters'
env_name = default_sat.create_custom_environment(repo=puppet_class)
puppet_class = entities.PuppetClass().search(
query={
'search': f'name = "{puppet_class}" and environment = "{env_name}"'
})[0]
sc_params_list = entities.SmartClassParameters().search(query={
'search': f'puppetclass="{puppet_class.name}"',
'per_page': '1000'
})
env = entities.Environment().search(
query={'search': f'name="{env_name}"'})[0].read()
yield {'env': env, 'class': puppet_class, 'sc_params': sc_params_list}
delete_puppet_class(puppet_class.name)
def test_positive_end_to_end(session, module_org, module_loc):
"""Perform end to end testing for puppet class component
:id: f837eec0-101c-4aff-a270-652005bdee51
:expectedresults: All expected CRUD actions finished successfully
:CaseLevel: Integration
:CaseImportance: High
"""
variable_name = gen_string('alpha')
name = gen_string('alpha')
hostgroup = entities.HostGroup(organization=[module_org],
location=[module_loc]).create()
puppet_class = entities.PuppetClass(name=name).create()
entities.SmartVariable(variable=variable_name,
puppetclass=puppet_class).create()
with session:
# Check that created puppet class can be found in UI
assert session.puppetclass.search(name)[0]['Class name'] == name
# Read puppet class values and check that they are expected
pc_values = session.puppetclass.read(name)
assert pc_values['puppet_class']['name'] == name
assert not pc_values['puppet_class']['puppet_environment']
assert not pc_values['puppet_class']['host_group']['assigned']
assert pc_values['smart_variables']['variable']['key'] == variable_name
# Update puppet class
session.puppetclass.update(
puppet_class.name,
{'puppet_class.host_group.assigned': [hostgroup.name]})
pc_values = session.puppetclass.read(name)
assert pc_values['puppet_class']['host_group']['assigned'] == [
hostgroup.name
]
# Make an attempt to delete puppet class that associated with host group
with raises(AssertionError) as context:
session.puppetclass.delete(name)
assert "error: '{} is used by {}'".format(
puppet_class.name, hostgroup.name) in str(context.value)
# Unassign puppet class from host group
session.puppetclass.update(
puppet_class.name,
{'puppet_class.host_group.unassigned': [hostgroup.name]})
# Delete puppet class
session.puppetclass.delete(name)
assert not session.puppetclass.search(name)
def setUpClass(cls):
"""Import some parametrized puppet classes. This is required to make
sure that we have data to be able to perform interactions with smart
class variables.
"""
super(SmartVariablesTestCase, cls).setUpClass()
cls.puppet_module = "puppetlabs/ntp"
cls.host_name = settings.server.hostname
ssh.command(
'puppet module install --force {0}'.format(cls.puppet_module))
cls.env = entities.Environment().search(
query={'search': 'name="production"'}
)
if len(cls.env) == 0:
raise Exception("Environment not found")
cls.env = cls.env[0]
cls.proxy = entities.SmartProxy(name=cls.host_name).search()[0]
cls.proxy.import_puppetclasses(environment=cls.env)
cls.puppet = entities.PuppetClass().search(
query={'search': 'name="ntp"'}
)[0]
def test_positive_update_variable_puppet_class(self):
"""Update Smart Variable's puppet class.
@id: 2312cb28-c3b0-4fbc-84cf-b66f0c0c64f0
@steps:
1. Create a smart variable with valid name.
2. Update the puppet class associated to the smart variable created in
step1.
@assert: The variable is updated with new puppet class.
"""
smart_variable = entities.SmartVariable(
puppetclass=self.puppet,
).create()
self.assertEqual(smart_variable.puppetclass.id, self.puppet.id)
new_puppet = entities.PuppetClass().search(
query={'search': 'name="ntp::config"'}
)[0]
smart_variable.puppetclass = new_puppet
updated_sv = smart_variable.update(['puppetclass'])
self.assertEqual(updated_sv.puppetclass.id, new_puppet.id)
def _setup_scenario(self, default_sat):
"""Import some parametrized puppet classes. This is required to make
sure that we have smart class variable available.
Read all available smart class parameters for imported puppet class to
be able to work with unique entity for each specific test.
"""
self.org = entities.Organization().create()
repo = 'api_test_classparameters'
env_name = default_sat.create_custom_environment(repo=repo)
self.puppet_class = entities.PuppetClass().search(
query={
'search': f'name = "{repo}" and environment = "{env_name}"'
})[0]
self.sc_params_list = entities.SmartClassParameters().search(
query={
'search': f'puppetclass="{self.puppet_class.name}"',
'per_page': 1000
})
scenario_ents = {
self.__class__.__name__: {
'puppet_class': self.puppet_class.name
}
}
create_dict(scenario_ents)
def test_positive_delete(session):
puppet_class = entities.PuppetClass().create()
with session:
session.puppetclass.delete(puppet_class.name)
assert not session.puppetclass.search(puppet_class.name)
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 module_puppet_class():
return entities.PuppetClass().create()
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)
