def test_negative_validate_matcher_and_default_value(self):
"""Error for invalid default and matcher value both at a time.
@id: 07dfcdad-e619-4672-9fe8-75a8352e44a4
@steps:
1. Override the parameter.
2. Update parameter default type with Invalid value.
3. Create a matcher with value that doesn't matches the default type.
4. Attempt to submit the change.
@assert: Error raised for invalid default and matcher value both.
"""
sc_param_id = self.sc_params_ids_list.pop()
SmartClassParameter.add_override_value({
'smart-class-parameter-id': sc_param_id,
'match': 'domain=test.com',
'value': gen_string('alpha'),
})
with self.assertRaises(CLIReturnCodeError):
SmartClassParameter.update({
'id': sc_param_id,
'parameter-type': 'boolean',
'override': 1,
'default-value': gen_string('alpha'),
})
def create_fake_host(session, host, interface_id=gen_string('alpha'),
global_parameters=None, host_parameters=None, extra_values=None):
if extra_values is None:
extra_values = {}
os_name = u'{0} {1}'.format(
host.operatingsystem.name, host.operatingsystem.major)
name = host.name if host.name is not None else gen_string('alpha').lower()
values = {
'host.name': name,
'host.organization': host.organization.name,
'host.location': host.location.name,
'host.lce': ENVIRONMENT,
'host.content_view': DEFAULT_CV,
'host.puppet_environment': host.environment.name,
'operating_system.architecture': host.architecture.name,
'operating_system.operating_system': os_name,
'operating_system.media_type': 'All Media',
'operating_system.media': host.medium.name,
'operating_system.ptable': host.ptable.name,
'operating_system.root_password': host.root_pass,
'interfaces.interface.interface_type': 'Interface',
'interfaces.interface.device_identifier': interface_id,
'interfaces.interface.mac': host.mac,
'interfaces.interface.domain': host.domain.name,
'interfaces.interface.primary': True,
'interfaces.interface.interface_additional_data.virtual_nic': False,
'parameters.global_params': global_parameters,
'parameters.host_params': host_parameters,
}
values.update(extra_values)
session.host.create(values)
return '{0}.{1}'.format(name, host.domain.name)
def test_positive_create_with_multiple_orgs(session):
"""Create User associated to multiple Orgs
:id: d74c0284-3995-4a4a-8746-00858282bf5d
:expectedresults: User is created successfully
:CaseLevel: Integration
"""
name = gen_string('alpha')
org_name1 = gen_string('alpha')
org_name2 = gen_string('alpha')
password = gen_string('alpha')
for org_name in [org_name1, org_name2]:
entities.Organization(name=org_name).create()
with session:
session.organization.select(org_name=DEFAULT_ORG)
session.user.create({
'user.login': name,
'user.auth': 'INTERNAL',
'user.password': password,
'user.confirm': password,
'organizations.resources.assigned': [org_name1, org_name2],
})
assert session.user.search(name) == name
user_values = session.user.read(name)
assert (
set(user_values['organizations']['resources']['assigned']) ==
set([DEFAULT_ORG, org_name1, org_name2])
)
def test_positive_search_by_parameter_with_prefix(session, module_loc):
"""Search by global parameter assigned to host using prefix 'not' and
any random string as parameter value to make sure that all hosts will
be present in the list
:id: a4affb90-1222-4d9a-94be-213f9e5be573
:expectedresults: All assigned hosts to organization are returned by
search
:CaseLevel: Integration
"""
org = entities.Organization().create()
param_name = gen_string('alpha')
param_value = gen_string('alpha')
search_param_value = gen_string('alphanumeric')
parameters = [{'name': param_name, 'value': param_value}]
param_host = entities.Host(
organization=org,
location=module_loc,
host_parameters_attributes=parameters,
).create()
additional_host = entities.Host(organization=org, location=module_loc).create()
with session:
session.organization.select(org_name=org.name)
# Check that the hosts are present
for host in [param_host, additional_host]:
assert session.host.search(host.name)[0]['Name'] == host.name
# Check that search by parameter with 'not' prefix returns both hosts
values = session.host.search('not params.{0} = {1}'.format(param_name, search_param_value))
assert {value['Name'] for value in values} == {param_host.name, additional_host.name}
def test_positive_rename(session):
name = gen_string('alpha')
new_name = gen_string('alpha')
entities.ComputeProfile(name=name).create()
with session:
session.computeprofile.rename(name, {'name': new_name})
assert session.computeprofile.search(new_name)[0]['Name'] == new_name
def test_positive_create_with_inherited_params(session):
"""Create a new Host in organization and location with parameters
:BZ: 1287223
:id: 628122f2-bda9-4aa1-8833-55debbd99072
:expectedresults: Host has inherited parameters from organization and
location
:CaseImportance: High
"""
org = entities.Organization().create()
loc = entities.Location(organization=[org]).create()
org_param = dict(name=gen_string('alphanumeric'), value=gen_string('alphanumeric'))
loc_param = dict(name=gen_string('alphanumeric'), value=gen_string('alphanumeric'))
host_template = entities.Host(organization=org, location=loc)
host_template.create_missing()
host_name = u'{0}.{1}'.format(host_template.name, host_template.domain.name)
with session:
session.organization.update(org.name, {'parameters.resources': org_param})
session.location.update(loc.name, {'parameters.resources': loc_param})
session.organization.select(org_name=org.name)
session.location.select(loc_name=loc.name)
create_fake_host(session, host_template)
values = session.host.read(host_name, 'parameters')
expected_params = {(org_param['name'], org_param['value']),
(loc_param['name'], loc_param['value'])}
assert expected_params.issubset(
{(param['name'], param['value']) for param in values['parameters']['global_params']}
)
def test_positive_search_by_parameter(session, module_org, module_loc):
"""Search for the host by global parameter assigned to it
:id: 8e61127c-d0a0-4a46-a3c6-22d3b2c5457c
:expectedresults: Only one specific host is returned by search
:CaseLevel: Integration
"""
param_name = gen_string('alpha')
param_value = gen_string('alpha')
parameters = [{'name': param_name, 'value': param_value}]
param_host = entities.Host(
organization=module_org,
location=module_loc,
host_parameters_attributes=parameters,
).create()
additional_host = entities.Host(organization=module_org, location=module_loc).create()
with session:
# Check that hosts present in the system
for host in [param_host, additional_host]:
assert session.host.search(host.name)[0]['Name'] == host.name
# Check that search by parameter returns only one host in the list
values = session.host.search('params.{0} = {1}'.format(param_name, param_value))
assert len(values) == 1
assert values[0]['Name'] == param_host.name
def test_positive_delete_job_template(self):
"""Delete a job template
:id: b25e4fb9-ad75-407d-b15f-76df381c4f9c
:Setup: Create a valid job template.
:Steps:
1. Click the dropdown next to the Job Template's Run button
2. Select Delete from the list
3. Confirm the deletion
:expectedresults: The Job Template has been deleted
:CaseImportance: Critical
"""
name = gen_string('alpha')
with Session(self) as session:
make_job_template(
session,
name=name,
template_type='input',
template_content=gen_string('alphanumeric', 20),
)
self.jobtemplate.delete(name, dropdown_present=True)
def invalid_sc_parameters_data():
"""Returns a list of invalid smart class parameter types and values"""
return [
{
u'sc_type': 'boolean',
u'value': gen_string('alphanumeric'),
},
{
u'sc_type': 'integer',
u'value': gen_string('utf8'),
},
{
u'sc_type': 'real',
u'value': gen_string('alpha'),
},
{
u'sc_type': 'array',
u'value': '0',
},
{
u'sc_type': 'hash',
u'value': 'a:test',
},
{
u'sc_type': 'yaml',
u'value': '{a:test}',
},
{
u'sc_type': 'json',
u'value': gen_string('alpha'),
},
]
def test_positive_create_with_multiple_roles(session):
"""Create User with multiple roles
:id: d3cc4434-25ca-4465-8878-42495390c17b
:expectedresults: User is created successfully and has proper roles
assigned
:CaseLevel: Integration
"""
name = gen_string('alpha')
role1 = gen_string('alpha')
role2 = gen_string('alpha')
password = gen_string('alpha')
for role in [role1, role2]:
entities.Role(name=role).create()
with session:
session.user.create({
'user.login': name,
'user.auth': 'INTERNAL',
'user.password': password,
'user.confirm': password,
'roles.resources.assigned': [role1, role2],
})
assert session.user.search(name) == name
user_values = session.user.read(name)
assert (
set(user_values['roles']['resources']['assigned']) ==
set([role1, role2])
)
def test_positive_view_diff(self):
"""View diff within template editor
@id: 4b8fff93-4862-4119-bb97-aadc50fc817d
@Setup: Create a valid job template.
@Steps:
1. Open the job template created during setup
2. Modify the template's code
3. Click the Diff button
@Assert: Verify that the new changes are displayed in the window
"""
name = gen_string('alpha')
old_template = gen_string('alpha')
new_template = gen_string('alphanumeric')
with Session(self.browser) as session:
make_job_template(
session,
name=name,
template_type='input',
template_content=old_template,
)
self.jobtemplate.click(self.jobtemplate.search(name))
self.jobtemplate.assign_value(
locators['job.template_input'], new_template)
self.jobtemplate.click(common_locators['ace.diff'])
template_text = self.jobtemplate.wait_until_element(
locators['job.template_input']).text
self.assertIn('-' + old_template, template_text)
self.assertIn('+' + new_template, template_text)
def test_negative_validate_matcher_value_with_regex(self):
"""Error raised for matcher value not matching with regex.
@id: b8b2f1c2-a20c-42d6-a687-79e6eee0268e
@steps:
1. Override the parameter.
2. Create a matcher with value that doesn't match
the regex of step 3.
3. Validate this value with regex validator type and rule.
4. Submit the change.
@assert: Error raised for matcher value not matching with regex.
"""
value = gen_string('numeric')
sc_param_id = self.sc_params_ids_list.pop()
SmartClassParameter.add_override_value({
'smart-class-parameter-id': sc_param_id,
'match': 'domain=test.com',
'value': gen_string('alpha')
})
with self.assertRaises(CLIReturnCodeError):
SmartClassParameter.update({
'id': sc_param_id,
'default-value': value,
'override': 1,
'validator-type': 'regexp',
'validator-rule': '[0-9]',
})
sc_param = SmartClassParameter.info({
'puppet-class': self.puppet_class['name'],
'id': sc_param_id,
})
self.assertNotEqual(sc_param['default-value'], value)
def test_positive_upstream_with_credentials(session, module_prod):
"""Create repository with upstream username and password update them and then clear them.
:id: 141a95f3-79c4-48f8-9c95-e4b128045cb3
:expectedresults:
1. The custom repository is created with upstream credentials.
2. The custom repository upstream credentials are updated.
3. The credentials are cleared.
:CaseLevel: Integration
:CaseImportance: High
:BZ: 1433481
"""
repo_name = gen_string('alpha')
upstream_username = gen_string('alpha')
upstream_password = gen_string('alphanumeric')
new_upstream_username = gen_string('alpha')
new_upstream_password = gen_string('alphanumeric')
hidden_password = '******' * 8
with session:
session.repository.create(
module_prod.name,
{
'name': repo_name,
'repo_type': REPO_TYPE['yum'],
'repo_content.upstream_url': FAKE_1_YUM_REPO,
'repo_content.upstream_username': upstream_username,
'repo_content.upstream_password': upstream_password,
}
)
assert session.repository.search(module_prod.name, repo_name)[0]['Name'] == repo_name
repo_values = session.repository.read(module_prod.name, repo_name)
assert repo_values['repo_content']['upstream_authorization'] == '{0} / {1}'.format(
upstream_username, hidden_password)
session.repository.update(
module_prod.name,
repo_name,
{
'repo_content.upstream_authorization': dict(
username=new_upstream_username,
password=new_upstream_password
),
}
)
repo_values = session.repository.read(module_prod.name, repo_name)
assert repo_values['repo_content']['upstream_authorization'] == '{0} / {1}'.format(
new_upstream_username, hidden_password)
session.repository.update(
module_prod.name,
repo_name,
{
'repo_content.upstream_authorization': {},
}
)
repo_values = session.repository.read(module_prod.name, repo_name)
assert not repo_values['repo_content']['upstream_authorization']
def test_positive_assign_cloned_role(session):
"""Clone role and assign it to user
:id: cbb17f37-9039-4875-981b-1f427b095ed1
:customerscenario: true
:expectedresults: User is created successfully
:BZ: 1353788
:CaseImportance: Critical
"""
role_name = random.choice(ROLES)
cloned_role_name = gen_string('alpha')
user_name = gen_string('alpha')
user_password = gen_string('alpha')
with session:
session.role.clone(role_name, {'name': cloned_role_name})
assert session.role.search(cloned_role_name)[0]['Name'] == cloned_role_name
session.user.create({
'user.login': user_name,
'user.auth': 'INTERNAL',
'user.password': user_password,
'user.confirm': user_password,
'roles.resources.assigned': [cloned_role_name],
})
assert session.user.search(user_name)[0]['Username'] == user_name
user = session.user.read(user_name)
assert user['roles']['resources']['assigned'] == [cloned_role_name]
def test_positive_update_parameter(self):
"""Subnet parameter can be updated
:id: 8c389c3f-60ef-4856-b8fc-c5b066c67a2f
:steps:
1. Create valid subnet with valid parameter
2. Update above subnet parameter with new name and
value
:expectedresults: The parameter name and value should be updated
"""
parameter = [{
'name': gen_string('alpha'), 'value': gen_string('alpha')
}]
subnet = entities.Subnet(
subnet_parameters_attributes=parameter).create()
update_parameter = [{
'name': gen_string('utf8'), 'value': gen_string('utf8')
}]
subnet.subnet_parameters_attributes = update_parameter
up_subnet = subnet.update(['subnet_parameters_attributes'])
self.assertEqual(
up_subnet.subnet_parameters_attributes[0]['name'],
update_parameter[0]['name']
)
self.assertEqual(
up_subnet.subnet_parameters_attributes[0]['value'],
update_parameter[0]['value']
)
def test_positive_edit_resource_description(
session, module_ca_cert, rhev_data, version):
"""Edit RHEV Compute Resource with another description
:id: f75544b1-3943-4cc6-98d1-f2d0fbe7244c
:expectedresults: resource updated successfully and has new description
:CaseLevel: Integration
"""
name = gen_string('alpha')
description = gen_string('alpha')
new_description = gen_string('alpha')
with session:
session.computeresource.create({
'name': name,
'description': description,
'provider': FOREMAN_PROVIDERS['rhev'],
'provider_content.url': rhev_data['rhev_url'],
'provider_content.user': rhev_data['username'],
'provider_content.password': rhev_data['password'],
'provider_content.api4': version,
'provider_content.datacenter.value': rhev_data['datacenter'],
'provider_content.certification_authorities': module_ca_cert
})
resource_values = session.computeresource.read(name)
assert resource_values['description'] == description
session.computeresource.edit(name, {'description': new_description})
resource_values = session.computeresource.read(name)
assert resource_values['description'] == new_description
def test_negative_update_parameter(self):
"""Subnet parameter can not be updated with invalid names
:id: fcdbad13-ad96-4152-8e20-e023d61a2853
:steps:
1. Create valid subnet with valid parameter
2. Update above subnet parameter with some invalid
name. e.g name with spaces
:expectedresults:
1. The parameter should not be updated with invalid name
2. An error for invalid name should be thrown
"""
subnet = entities.Subnet().create()
sub_param = entities.Parameter(
name=gen_string('utf8'),
subnet=subnet.id,
value=gen_string('utf8')
).create()
invalid_values = invalid_values_list() + ['name with space']
for new_name in invalid_values:
with self.subTest(new_name):
with self.assertRaises(HTTPError):
sub_param.name = new_name
sub_param.update(['name'])
def test_negative_create_job_template_with_same_name(self):
"""Create Job Template with duplicate name
:id: 2c193758-dc34-4701-863c-f2823851223a
:Steps:
1. Create a new job template.
2. Enter a name that has already been used
3. Click submit
:expectedresults: The name duplication is caught and error is raised
:CaseImportance: Critical
"""
name = gen_string('alpha')
with Session(self) as session:
make_job_template(
session,
name=name,
template_type='input',
template_content=gen_string('alphanumeric', 20),
)
self.assertIsNotNone(self.jobtemplate.search(name))
make_job_template(
session,
name=name,
template_type='input',
template_content=gen_string('alphanumeric', 20),
)
self.assertIsNotNone(self.jobtemplate.wait_until_element(
common_locators['name_haserror']))
def test_positive_search_by_parameter_with_different_values(session, module_org, module_loc):
"""Search for the host by global parameter assigned to it by its value
:id: c3a4551e-d759-4a9d-ba90-8db4cab3db2c
:expectedresults: Only one specific host is returned by search
:CaseLevel: Integration
"""
param_name = gen_string('alpha')
param_values = [gen_string('alpha'), gen_string('alphanumeric')]
hosts = [
entities.Host(
organization=module_org,
location=module_loc,
host_parameters_attributes=[{'name': param_name, 'value': param_value}]
).create()
for param_value in param_values
]
with session:
# Check that hosts present in the system
for host in hosts:
assert session.host.search(host.name)[0]['Name'] == host.name
# Check that search by parameter returns only one host in the list
for param_value, host in zip(param_values, hosts):
values = session.host.search('params.{0} = {1}'.format(param_name, param_value))
assert len(values) == 1
assert values[0]['Name'] == host.name
def test_positive_create_with_long_priority_list(session, puppet_class):
"""Smart variable priority order list can contain more than 255 character inside of it.
:id: 440923cb-9d81-40c8-9d81-7bf22f503cf5
:customerscenario: true
:steps:
1. Create variable with some default value.
2. Set long priority order list
:expectedresults: Smart variable is created successfully and has proper priority list.
:BZ: 1458817
:CaseImportance: Medium
"""
name = gen_string('alpha')
order_value = '\n'.join([gen_string('alpha').lower() for _ in range(60)])
assert len(order_value) > 255
with session:
session.smartvariable.create({
'variable.key': name,
'variable.puppet_class': puppet_class.name,
'variable.default_value': gen_string('alpha'),
'variable.prioritize_attribute_order.order': order_value,
})
values = session.smartvariable.read(name)
assert values['variable']['prioritize_attribute_order']['order'] == order_value
def test_positive_end_to_end(session, oscap_tailoring_path):
"""Perform end to end testing for tailoring file component
:id: 9aebccb8-6837-4583-8a8a-8883480ab688
:expectedresults: All expected CRUD actions finished successfully
:CaseLevel: Integration
:CaseImportance: High
"""
name = gen_string('alpha')
new_name = gen_string('alpha')
org = entities.Organization().create()
loc = entities.Location().create()
with session:
session.oscaptailoringfile.create({
'file_upload.name': name,
'file_upload.scap_file': oscap_tailoring_path,
'organizations.resources.assigned': [org.name],
'locations.resources.assigned': [loc.name],
})
assert session.oscaptailoringfile.search(name)[0]['Name'] == name
tailroingfile_values = session.oscaptailoringfile.read(name)
assert tailroingfile_values['file_upload']['name'] == name
assert tailroingfile_values['file_upload'][
'uploaded_scap_file'] == oscap_tailoring_path.rsplit('/', 1)[-1]
assert org.name in tailroingfile_values['organizations']['resources']['assigned']
assert loc.name in tailroingfile_values['locations']['resources']['assigned']
session.oscaptailoringfile.update(name, {'file_upload.name': new_name})
assert session.oscaptailoringfile.search(new_name)[0]['Name'] == new_name
assert not session.oscaptailoringfile.search(name)
session.oscaptailoringfile.delete(new_name)
assert not session.oscaptailoringfile.search(new_name)
def test_positive_clone(session):
"""Assure ability to clone a report template
:id: 912f1619-abb0-4e0f-88ce-88b5726fdbe0
:Steps:
1. Go to Report template UI
2. Choose a template and attempt to clone it
:expectedresults: The template is cloned
:CaseLevel: Integration
"""
name = gen_string('alpha')
clone_name = gen_string('alpha')
content = gen_string('alpha')
with session:
session.reporttemplate.create({
'template.name': name,
'template.template_editor.editor': content,
})
session.reporttemplate.clone(
name,
{
'template.name': clone_name,
}
)
assert session.reporttemplate.search(
clone_name)[0]['Name'] == clone_name
assert session.reporttemplate.read(
clone_name)['template']['template_editor']['editor'] == content
def test_positive_update_with_multiple_roles(session):
"""Update User with multiple roles
:id: 127fb368-09fd-4f10-8319-566a1bcb5cd2
:expectedresults: User is updated successfully
:CaseLevel: Integration
"""
name = gen_string('alpha')
role_names = [
entities.Role().create().name
for _ in range(3)
]
password = gen_string('alpha')
with session:
session.user.create({
'user.login': name,
'user.auth': 'INTERNAL',
'user.password': password,
'user.confirm': password,
})
session.user.update(
name,
{'roles.resources.assigned': role_names},
)
assert session.user.search(name) == name
user_values = session.user.read(name)
assert (
set(user_values['roles']['resources']['assigned']) ==
set(role_names)
)
def test_positive_create_job_template_input(self):
"""Create a Job Template using input
@id: dbaf5aa9-101d-47dc-bdf8-d5b4d1a52396
@Steps:
1. Navigate to Hosts -> Job Templates
2. Enter a name
3. Navigate to the job tab
4. Enter a job name
5. Click the +Add Input button
6. Add an appropriate name
7. Choose an input type
8. Populate the template code and reference the newly created input
9. Click submit
@Assert: The job template was successfully saved with new input added
"""
name = gen_string('alpha')
var_name = gen_string('alpha')
with Session(self.browser) as session:
make_job_template(
session,
name=name,
template_type='input',
template_content=gen_string('alphanumeric', 20),
)
self.assertIsNotNone(self.jobtemplate.search(name))
self.jobtemplate.add_input(name, var_name)
self.jobtemplate.update(
name,
template_type='input',
template_content='<%= input("{0}") %>'.format(var_name)
)
def test_positive_update_with_all_roles(session):
"""Update User with all roles
:id: cd7a9cfb-a700-45f2-a11d-bba6be3c810d
:expectedresults: User is updated successfully
:CaseLevel: Integration
"""
name = gen_string('alpha')
password = gen_string('alpha')
with session:
session.user.create({
'user.login': name,
'user.auth': 'INTERNAL',
'user.password': password,
'user.confirm': password,
})
session.user.update(
name,
{'roles.resources.assigned': ROLES},
)
assert session.user.search(name) == name
user_values = session.user.read(name)
assert (
set(user_values['roles']['resources']['assigned']) == set(ROLES))
def test_negative_preview_verify(self):
"""Use a template file to populate the job template
@id: 8c0d132c-b500-44b5-a549-d32c7636a712
@Steps:
1. Create a new job template
2. Add input controls under jobs
3. Incorrectly reference those input controls in the template text
4. And/or reference non-existent input controls in the template text
5. Select "preview" within the template viewer
@Assert: Verify appropriate errors are thrown
"""
name = gen_string('alpha')
with Session(self.browser) as session:
make_job_template(
session,
name=name,
template_type='input',
template_content=gen_string('alpha'),
org=self.organization.name,
)
self.jobtemplate.add_input(name, gen_string('alpha'))
self.jobtemplate.update(
name,
template_type='input',
template_content='<%= input("{0}") %>'.format(
gen_string('alphanumeric'))
)
self.jobtemplate.click(self.jobtemplate.search(name))
self.jobtemplate.click(common_locators['ace.preview'])
self.assertIsNotNone(self.jobtemplate.wait_until_element(
common_locators['alert.error']))
def test_positive_update_orgs(session):
"""Assign a User to multiple Orgs
:id: a207188d-1ad1-4ff1-9906-bae1d91104fd
:expectedresults: User is updated
:CaseLevel: Integration
"""
name = gen_string('alpha')
password = gen_string('alpha')
org_names = [
entities.Organization().create().name
for _ in range(3)
]
with session:
session.organization.select(org_name=random.choice(org_names))
session.user.create({
'user.login': name,
'user.auth': 'INTERNAL',
'user.password': password,
'user.confirm': password,
})
session.user.update(
name,
{'organizations.resources.assigned': org_names},
)
assert session.user.search(name) == name
user_values = session.user.read(name)
assert (
set(user_values['organizations']['resources']['assigned']) ==
set(org_names)
)
def test_positive_validate_matcher_value_with_regex(self):
"""Error not raised for matcher value matching with regex.
@id: 2c8273aa-e621-4d4e-b03e-f8d50a596bc2
@steps:
1. Override the parameter.
2. Create a matcher with value that matches the regex of step 3.
3. Validate this value with regex validator type and rule.
4. Submit the change.
@assert: Error not raised for matcher value matching with regex.
"""
value = gen_string('numeric')
sc_param_id = self.sc_params_ids_list.pop()
SmartClassParameter.add_override_value({
'smart-class-parameter-id': sc_param_id,
'match': 'domain=test.com',
'value': gen_string('numeric')
})
SmartClassParameter.update({
'id': sc_param_id,
'default-value': value,
'override': 1,
'validator-type': 'regexp',
'validator-rule': '[0-9]',
})
sc_param = SmartClassParameter.info({
'puppet-class': self.puppet_class['name'],
'id': sc_param_id,
})
self.assertEqual(sc_param['default-value'], value)
def test_positive_clone_job_template(self):
"""Clone a Job Template
:id: a1ec5d1d-907f-4d18-93d3-adb1134d9cca
:Setup: Create a valid job template.
:Steps:
1. Navigate to Hosts -> Job Templates
2. Click the clone button next to a job template
3. Change the name
4. Click submit
:expectedresults: Verify all job template contents were successfully
copied
:CaseImportance: Critical
"""
name = gen_string('alpha')
clone_name = gen_string('alpha')
with Session(self) as session:
make_job_template(
session,
name=name,
template_type='input',
template_content=gen_string('alphanumeric', 20),
)
self.assertIsNotNone(self.jobtemplate.search(name))
self.jobtemplate.clone(name, clone_name)
self.assertIsNotNone(self.jobtemplate.search(clone_name))
def test_positive_create_with_compresource(session,
module_docker_cr, module_prod):
"""Create containers for a compute resource
:id: 299fc13d-5c2f-4642-a6de-735c89fdd096
:expectedresults: The docker container is created for the compute
resource
:CaseLevel: Integration
"""
deploy_on = module_docker_cr.name + ' (Docker)'
repo_name = gen_string('alpha')
name = gen_string('alpha', 4).lower()
repo = entities.Repository(
name=repo_name,
url=DOCKER_REGISTRY_HUB,
product=module_prod,
content_type=REPO_TYPE['docker'],
docker_upstream_name="centos"
).create()
repo.sync()
with session:
session.container.create({
'preliminary.compute_resource.deploy_on': deploy_on,
'image.content_view.lifecycle_environment': ENVIRONMENT,
'image.content_view.content_view': DEFAULT_CV,
'image.content_view.repository': repo.name,
'image.content_view.tag': 'centos7.2.1511',
'image.content_view.capsule': settings.server.hostname,
'configuration.name': name,
'configuration.command': 'top',
'environment.tty': True,
})
assert session.container.search(name)[0]['Name'].lower() == name
def test_positive_update_restrict_composite_view(session,
set_original_property_value):
"""Update settings parameter restrict_composite_view to Yes/True and ensure
a composite content view may not be published or promoted, unless the component
content view versions that it includes exist in the target environment.
:id: a5d2d73d-064e-48af-ad62-da68e963e3ee
:expectedresults: Parameter is updated successfully
:CaseImportance: Critical
:CaseLevel: Acceptance
"""
repo_name = gen_string('alpha')
property_name = 'restrict_composite_view'
set_original_property_value(property_name)
org = entities.Organization().create()
product = entities.Product(organization=org).create()
lce = entities.LifecycleEnvironment(organization=org).create()
repo = entities.Repository(name=repo_name, product=product).create()
composite_cv = entities.ContentView(
composite=True,
organization=org,
).create()
add_content_views_to_composite(composite_cv, org, repo)
composite_cv.publish()
with session:
session.organization.select(org_name=org.name)
for param_value in ('Yes', 'No'):
session.settings.update('name = {}'.format(property_name),
param_value)
if param_value == 'Yes':
with raises(AssertionError) as context:
session.contentview.promote(composite_cv.name,
'Version 1.0', lce.name)
assert 'Administrator -> Settings -> Content page using the ' \
'restrict_composite_view flag.' in str(context.value)
else:
result = session.contentview.promote(composite_cv.name,
'Version 1.0', lce.name)
assert lce.name in result['Environments']
def test_positive_resource_vm_power_management(session, rhev_data):
"""Read current RHEV Compute Resource virtual machine power status and
change it to opposite one
:id: 47aea4b7-9258-4863-8966-900bc9e94116
:parametrized: yes
:expectedresults: virtual machine is powered on or powered off depending on
its initial state
:CaseLevel: Integration
"""
name = gen_string('alpha')
with session:
session.computeresource.create(
{
'name': name,
'provider': FOREMAN_PROVIDERS['rhev'],
'provider_content.url': rhev_data['rhev_url'],
'provider_content.user': rhev_data['username'],
'provider_content.password': rhev_data['password'],
'provider_content.datacenter.value': rhev_data['datacenter'],
'provider_content.certification_authorities': rhev_data['cert'],
}
)
status = session.computeresource.vm_status(name, rhev_data['vm_name'])
if status:
session.computeresource.vm_poweroff(name, rhev_data['vm_name'])
else:
session.computeresource.vm_poweron(name, rhev_data['vm_name'])
wait_for(
lambda: (
session.browser.refresh(),
session.computeresource.vm_status(name, rhev_data['vm_name']),
)[1]
is not status,
timeout=180,
delay=1,
)
assert session.computeresource.vm_status(name, rhev_data['vm_name']) is not status
def test_positive_add_product_with_repos(session, module_org, gpg_content):
"""Create gpg key with valid name and valid gpg key then associate it
with custom product that has more than one repository
:id: 0edffad7-0ab4-4bef-b16b-f6c8de55b0dc
:expectedresults: gpg key is properly associated with repositories
:CaseLevel: Integration
"""
name = gen_string('alpha')
gpg_key = entities.GPGKey(
content=gpg_content,
name=name,
organization=module_org,
).create()
# Creates new product and associate GPGKey with it
product = entities.Product(
gpg_key=gpg_key,
organization=module_org,
).create()
# Creates new repository_1 without GPGKey
repo1 = entities.Repository(
product=product,
url=FAKE_1_YUM_REPO,
).create()
# Creates new repository_2 without GPGKey
repo2 = entities.Repository(
product=product,
url=FAKE_2_YUM_REPO,
).create()
with session:
values = session.contentcredential.read(name)
assert len(values['repositories']['table']) == 2
assert (
{repo1.name, repo2.name} ==
set([
repo['Name']
for repo
in values['repositories']['table']
])
)
def test_positive_end_to_end_custom_module_streams_crud(
session, module_org, module_prod):
"""Perform end to end testing for custom module streams yum repository
:id: ea0a58ae-b280-4bca-8f22-cbed73453604
:expectedresults: All expected CRUD actions finished successfully
:CaseLevel: Integration
:CaseImportance: High
"""
repo_name = gen_string('alpha')
with session:
session.repository.create(
module_prod.name,
{
'name': repo_name,
'repo_type': REPO_TYPE['yum'],
'repo_content.upstream_url':
settings.repos.module_stream_1.url,
},
)
assert session.repository.search(module_prod.name,
repo_name)[0]['Name'] == repo_name
repo_values = session.repository.read(module_prod.name, repo_name)
assert repo_values['repo_content'][
'upstream_url'] == settings.repos.module_stream_1.url
result = session.repository.synchronize(module_prod.name, repo_name)
assert result['result'] == 'success'
repo_values = session.repository.read(module_prod.name, repo_name)
assert int(repo_values['content_counts']['Module Streams']) >= 5
session.repository.update(
module_prod.name,
repo_name,
{'repo_content.upstream_url': settings.repos.module_stream_0.url},
)
repo_values = session.repository.read(module_prod.name, repo_name)
assert repo_values['repo_content'][
'upstream_url'] == settings.repos.module_stream_0.url
session.repository.delete(module_prod.name, repo_name)
assert not session.repository.search(module_prod.name, repo_name)
def test_positive_update_by_type():
"""Update some entities of different types and check audit logs for
these events using entity type as search criteria
:id: 43e73a11-b241-4b91-bdf6-e966366014e8
:expectedresults: Audit logs contain corresponding entries per each
update event
:CaseImportance: Medium
:CaseComponent: AuditLog
:Assignee: rplevka
"""
for entity in [
entities.Architecture(),
entities.Domain(),
entities.HostGroup(),
entities.Location(),
entities.Organization(),
entities.Role(),
entities.UserGroup(),
]:
created_entity = entity.create()
name = created_entity.name
new_name = gen_string('alpha')
created_entity.name = new_name
created_entity = created_entity.update(['name'])
audits = entities.Audit().search(
query={
'search': f'type={created_entity.__class__.__name__.lower()}'
})
entity_audits = [
entry for entry in audits if entry.auditable_name == name
]
assert entity_audits, f'audit not found by name "{name}"'
audit = entity_audits[0]
assert audit.auditable_id == created_entity.id
assert audit.audited_changes['name'] == [name, new_name]
assert audit.action == 'update'
assert audit.version == 2
def test_positive_update_email_subject_prefix(self):
"""Check email subject prefix is updated
:id: c8e6b323-7b39-43d6-a9f1-5474f920bba2
:expectedresults: email_subject_prefix is updated
:caseautomation: automated
:caseimportance: low
"""
email_subject_prefix_value = gen_string('alpha')
Settings.set({
'name': "email_subject_prefix",
'value': email_subject_prefix_value
})
email_subject_prefix = Settings.list(
{'search': 'name=email_subject_prefix'})[0]
self.assertEqual(email_subject_prefix_value,
email_subject_prefix['value'])
def test_positive_create_vmware(session, name):
vmware_vcenter = settings.vmware.vcenter
vmware_user = settings.vmware.username
vmware_password = settings.vmware.password
with session:
session.computeresource.create({
'name':
name,
'description':
gen_string('alpha'),
'provider':
FOREMAN_PROVIDERS['vmware'],
'provider_content.vcenter':
vmware_vcenter,
'provider_content.user':
vmware_user,
'provider_content.password':
vmware_password,
})
assert session.computeresource.search(name)[0]['Name'] == name
def test_positive_delete(session, module_container_host):
"""Delete containers in an external compute resource
:id: e69808e7-6a0c-4310-b57a-2271ac61d11a
:expectedresults: The docker containers are deleted
:CaseLevel: Integration
"""
container = entities.DockerHubContainer(
compute_resource=module_container_host.compute_resource,
location=[module_container_host.location],
name=gen_string('alpha', 4).lower(),
organization=[module_container_host.organization],
).create()
with session:
assert session.container.search(container.name)[0]['Name'].lower() == container.name
session.container.delete(container.name)
assert container.name not in [
el['Name'] for el in session.container.search(container.name)]
def test_negative_override(self, module_sc_params):
"""Override the Default Parameter value - override Unchecked.
:id: eb24c44d-0e34-40a3-aa3e-05a3cd4ed1ea
:steps:
1. Don't override the parameter.
2. Set the new valid Default Value.
3. Attempt to submit the changes.
:expectedresults: Not overridden parameter value cannot be updated.
:BZ: 1830834
:CaseImportance: Medium
"""
sc_param_id = module_sc_params['ids'].pop()
with pytest.raises(CLIReturnCodeError):
SmartClassParameter.update({'default-value': gen_string('alpha'), 'id': sc_param_id})
def test_positive_add_empty_product(session, module_org, gpg_content):
"""Create gpg key with valid name and valid gpg key then associate
it with empty (no repos) custom product
:id: e18ae9f5-43d9-4049-92ca-1eafaca05096
:expectedresults: gpg key is associated with product
:CaseLevel: Integration
"""
prod_name = gen_string('alpha')
gpg_key = entities.GPGKey(content=gpg_content,
organization=module_org).create()
with session:
session.product.create({'name': prod_name, 'gpg_key': gpg_key.name})
values = session.contentcredential.read(gpg_key.name)
assert len(values['products']['table']) == 1
assert values['products']['table'][0]['Name'] == prod_name
assert values['products']['table'][0][
'Used as'] == CONTENT_CREDENTIALS_TYPES['gpg']
def test_negative_create_ssh_key_with_invalid_name(self, create_user):
"""Attempt to add SSH key that has invalid name length
:id: e1e17839-a392-45bb-bb1e-28d3cd9dba1c
:steps:
1. Create new user with all the details
2. Attempt to add invalid ssh Key name to above user
:expectedresults: Satellite should raise Name is too long assertion
:CaseImportance: Critical
"""
invalid_ssh_key_name = gen_string('alpha', length=300)
with pytest.raises(HTTPError) as context:
entities.SSHKey(user=create_user['user'],
name=invalid_ssh_key_name,
key=self.gen_ssh_rsakey()).create()
assert re.search("Name is too long", context.value.response.text)
def test_negative_validate_matcher_non_existing_attribute(self):
"""Error while creating matcher for Non Existing Attribute.
@id: 5223e582-81b4-442d-b4ba-b16ede460ef6
@steps:
1. Override the parameter.
2. Create a matcher with non existing attribute in org.
4. Attempt to submit the change.
@assert: Error raised for non existing attribute.
"""
sc_param_id = self.sc_params_ids_list.pop()
with self.assertRaises(CLIReturnCodeError):
SmartClassParameter.add_override_value({
'smart-class-parameter-id': sc_param_id,
'match': 'non_existing_attribute',
'value': gen_string('alpha')
})
def test_negative_duplicate_name_variable(self):
"""Create Smart Variable with an existing name.
:id: cc219111-1d2a-47ae-9b22-0b399f2d586d
:steps:
1. Create a smart Variable with Valid name and default value.
2. Attempt to create a variable with same name from same/other
class.
:expectedresults: The variable with same name are not allowed to create
from any class.
:CaseImportance: Critical
"""
name = gen_string('alpha')
make_smart_variable({'variable': name, 'puppet-class': self.puppet_class['name']})
with self.assertRaises(CLIReturnCodeError):
SmartVariable.create({'variable': name, 'puppet-class': self.puppet_class['name']})
def test_positive_delete_cloned_builtin(session):
"""Delete cloned builtin role
:id: 7f0a595b-2b27-4dca-b15a-02cd2519b2f7
:customerscenario: true
:expectedresults: Role is deleted
:BZ: 1353788, 1426672
:CaseImportance: Critical
"""
role_name = random.choice(ROLES)
cloned_role_name = gen_string('alpha')
with session:
session.role.clone(role_name, {'name': cloned_role_name})
assert session.role.search(cloned_role_name)[0]['Name'] == cloned_role_name
session.role.delete(cloned_role_name)
assert not session.role.search(cloned_role_name)
def auth_source(module_org, module_location, ad_data):
ad_data = ad_data()
return 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()
def test_positive_create_ssh_key(self):
"""SSH Key can be added to User
:id: d00905f6-3a70-4e2f-a5ae-fcac18274bb7
:steps:
1. Create new user with all the details
2. Add SSH key to the above user
:expectedresults: SSH key should be added to user
:CaseImportance: Critical
"""
ssh_name = gen_string('alpha')
ssh_key = self.gen_ssh_rsakey()
user_sshkey = entities.SSHKey(
user=self.user, name=ssh_name, key=ssh_key).create()
self.assertEqual(ssh_name, user_sshkey.name)
self.assertEqual(ssh_key, user_sshkey.key)
def test_positive_host_dmi_uuid_duplicates(session, setting_update):
"""Check the setting host_dmi_uuid_duplicates value update.
:id: 529ddd3a-1271-4043-9006-eac436b08b11
:parametrized: yes
:BZ: 1975713
:expectedresults: Value of host_dmi_uuid_duplicates should be updated successfully
:CaseImportance: High
"""
property_value = gen_string("alpha")
property_name = setting_update.name
with session:
session.settings.update(f'name = {setting_update.name}',
property_value)
result = session.settings.read(f'name = {property_name}')
assert result['table'][0]['Value'].strip('[]') == property_value
def test_positive_read_from_details_page(session):
"""Create new Host and read all its content through details page
:id: ffba5d40-918c-440e-afbb-6b910db3a8fb
:expectedresults: Host is created and has expected content
:CaseLevel: System
"""
host = entities.Host()
host.create_missing()
os_name = u'{0} {1}'.format(
host.operatingsystem.name, host.operatingsystem.major)
interface_id = gen_string('alpha')
host_name = u'{0}.{1}'.format(host.name, host.domain.name)
with session:
session.organization.select(org_name=host.organization.name)
session.location.select(loc_name=host.location.name)
create_fake_host(session, host, interface_id)
assert session.host.search(host_name)[0]['Name'] == host_name
values = session.host.get_details(host_name)
assert values['properties']['properties_table'][
'Status'] == 'OK'
assert values['properties']['properties_table'][
'Build'] == 'Pending installation'
assert values['properties']['properties_table'][
'Domain'] == host.domain.name
assert values['properties']['properties_table'][
'MAC Address'] == host.mac
assert values['properties']['properties_table'][
'Puppet Environment'] == host.environment.name
assert values['properties']['properties_table'][
'Architecture'] == host.architecture.name
assert values['properties']['properties_table'][
'Operating System'] == os_name
assert values['properties']['properties_table'][
'Location'] == host.location.name
assert values['properties']['properties_table'][
'Organization'] == host.organization.name
assert values['properties']['properties_table'][
'Owner'] == values['current_user']
def test_positive_create_with_ad(session, ldap_data):
"""Create LDAP authentication with AD
:id: 02ca85b7-5029-4618-a835-63b002767cf7
:steps:
1. Create a new LDAP Auth source with AD.
2. Fill in all the fields appropriately for AD.
:expectedresults: Whether creating LDAP Auth with AD is successful.
:CaseImportance: Critical
"""
name = gen_string('alpha')
with session:
session.ldapauthentication.create({
'ldap_server.name':
name,
'ldap_server.host':
ldap_data['ldap_hostname'],
'ldap_server.server_type':
LDAP_SERVER_TYPE['UI']['ad'],
'account.account_name':
ldap_data['ldap_user_name'],
'account.password':
ldap_data['ldap_user_passwd'],
'account.base_dn':
ldap_data['base_dn'],
'account.groups_base_dn':
ldap_data['group_base_dn'],
'attribute_mappings.login':
LDAP_ATTR['login_ad'],
'attribute_mappings.first_name':
LDAP_ATTR['firstname'],
'attribute_mappings.last_name':
LDAP_ATTR['surname'],
'attribute_mappings.mail':
LDAP_ATTR['mail'],
})
assert session.ldapauthentication.read_table_row(name)['Name'] == name
def test_positive_resource_vm_power_management(session, module_vmware_settings):
"""Read current VMware Compute Resource virtual machine power status and
change it to opposite one
:id: faeabe45-5112-43a6-bde9-f869dfb26cf5
:expectedresults: virtual machine is powered on or powered off depending on its initial state
:CaseLevel: Integration
"""
cr_name = gen_string('alpha')
vm_name = module_vmware_settings['vm_name']
with session:
session.computeresource.create(
{
'name': cr_name,
'provider': FOREMAN_PROVIDERS['vmware'],
'provider_content.vcenter': module_vmware_settings['vcenter'],
'provider_content.user': module_vmware_settings['user'],
'provider_content.password': module_vmware_settings['password'],
'provider_content.datacenter.value': module_vmware_settings['datacenter'],
}
)
assert session.computeresource.search(cr_name)[0]['Name'] == cr_name
power_status = session.computeresource.vm_status(cr_name, vm_name)
if power_status:
session.computeresource.vm_poweroff(cr_name, vm_name)
else:
session.computeresource.vm_poweron(cr_name, vm_name)
try:
wait_for(
lambda: (
session.browser.refresh(),
session.computeresource.vm_status(cr_name, vm_name),
)[1]
is not power_status,
timeout=30,
delay=2,
)
except TimedOutError:
raise AssertionError('Timed out waiting for VM to toggle power state')
def create_fake_host(session, host, interface_id=gen_string('alpha')):
os_name = u'{0} {1}'.format(host.operatingsystem.name,
host.operatingsystem.major)
session.host.create({
'host.name':
host.name,
'host.organization':
host.organization.name,
'host.location':
host.location.name,
'host.lce':
ENVIRONMENT,
'host.content_view':
DEFAULT_CV,
'host.puppet_environment':
host.environment.name,
'operating_system.architecture':
host.architecture.name,
'operating_system.operating_system':
os_name,
'operating_system.media_type':
'All Media',
'operating_system.media':
host.medium.name,
'operating_system.ptable':
host.ptable.name,
'operating_system.root_password':
host.root_pass,
'interfaces.interface.interface_type':
'Interface',
'interfaces.interface.device_identifier':
interface_id,
'interfaces.interface.mac':
host.mac,
'interfaces.interface.domain':
host.domain.name,
'interfaces.interface.primary':
True,
'interfaces.interface.interface_additional_data.virtual_nic':
False,
})
def test_positive_list_with_non_admin_user(self,
session_puppet_enabled_sat,
module_puppet):
"""List all the parameters for specific puppet class by id.
:id: 00fbf150-34fb-45d0-80e9-d5798d24a24f
:expectedresults: Parameters listed for specific Puppet class.
:BZ: 1391556
:CaseImportance: Medium
"""
password = gen_string('alpha')
required_user_permissions = {
'ForemanPuppet::Puppetclass': {
'permissions': ['view_puppetclasses']
},
'ForemanPuppet::PuppetclassLookupKey': {
'permissions': [
'view_external_parameters',
'create_external_parameters',
'edit_external_parameters',
'destroy_external_parameters',
]
},
}
user = make_user({'admin': '0', 'password': password})
role = make_role()
add_role_permissions(role['id'], required_user_permissions)
# Add the created and initiated role with permissions to user
session_puppet_enabled_sat.cli.User.add_role({
'id': user['id'],
'role-id': role['id']
})
sc_params = session_puppet_enabled_sat.cli.SmartClassParameter.with_user(
user['login'],
password).list({'puppet-class-id': module_puppet['class']['id']})
assert len(sc_params) > 0
# Check that only unique results are returned
assert len(sc_params) == len({scp['id'] for scp in sc_params})
def test_positive_delete_with_ad(session, ldap_data):
"""Delete LDAP authentication with AD
:steps:
1. Create a new LDAP Auth source with AD.
2. Delete LDAP Auth source with AD.
:expectedresults: Whether deleting LDAP Auth with AD is successful.
:CaseImportance: Critical
"""
name = gen_string('alpha')
with session:
session.ldapauthentication.create({
'ldap_server.name':
name,
'ldap_server.host':
ldap_data['ldap_hostname'],
'ldap_server.server_type':
LDAP_SERVER_TYPE['UI']['ad'],
'account.account_name':
ldap_data['ldap_user_name'],
'account.password':
ldap_data['ldap_user_passwd'],
'account.base_dn':
ldap_data['base_dn'],
'account.groups_base_dn':
ldap_data['group_base_dn'],
'attribute_mappings.login':
LDAP_ATTR['login_ad'],
'attribute_mappings.first_name':
LDAP_ATTR['firstname'],
'attribute_mappings.last_name':
LDAP_ATTR['surname'],
'attribute_mappings.mail':
LDAP_ATTR['mail'],
})
assert session.ldapauthentication.read_table_row(name)
session.ldapauthentication.delete(name)
assert not session.ldapauthentication.read_table_row(name)
def test_positive_override(self, session_puppet_enabled_sat, module_puppet,
module_sc_params):
"""Override the Default Parameter value.
:id: 25e34bac-084c-4b68-a082-822633e19f7e
:steps:
1. Override the parameter.
2. Set the new valid Default Value.
3. Set puppet default value to 'Use Puppet Default'.
4. Submit the changes.
:expectedresults: Parameter Value overridden with new value.
:BZ: 1830834
:customerscenario: true
:CaseImportance: Medium
"""
sc_param_id = module_sc_params['ids'].pop()
value = gen_string('alpha')
session_puppet_enabled_sat.cli.SmartClassParameter.update({
'default-value':
value,
'omit':
1,
'id':
sc_param_id,
'override':
1
})
sc_param = session_puppet_enabled_sat.cli.SmartClassParameter.info({
'puppet-class':
module_puppet['class']['name'],
'id':
sc_param_id
})
assert sc_param['default-value'] == value
assert sc_param['omit'] is True
def test_negative_validate_default_value_with_list(
self, session_puppet_enabled_sat, module_puppet, module_sc_params):
"""Error raised for default value not in list.
:id: cdcafbea-612e-4b60-90de-fa0c76442bbe
:steps:
1. Override the parameter.
2. Provide default value that doesn't matches the list of step 3.
3. Validate this value with list validator type and rule.
4. Submit the change.
:expectedresults: Error raised for default value not in list.
:customerscenario: true
:CaseImportance: Medium
"""
value = gen_string('alphanumeric')
sc_param_id = module_sc_params['ids'].pop()
with pytest.raises(CLIReturnCodeError):
session_puppet_enabled_sat.cli.SmartClassParameter.update({
'id':
sc_param_id,
'default-value':
value,
'override':
1,
'validator-type':
'list',
'validator-rule':
'5, test',
})
sc_param = session_puppet_enabled_sat.cli.SmartClassParameter.info({
'puppet-class':
module_puppet['class']['name'],
'id':
sc_param_id
})
assert sc_param['default-value'] != value
def test_positive_update_email_subject_prefix(setting_update):
"""Check email subject prefix is updated
:id: c8e6b323-7b39-43d6-a9f1-5474f920bba2
:parametrized: yes
:expectedresults: email_subject_prefix is updated
:CaseAutomation: Automated
:CaseImportance: Low
"""
email_subject_prefix_value = gen_string('alpha')
Settings.set({
'name': "email_subject_prefix",
'value': email_subject_prefix_value
})
email_subject_prefix = Settings.list(
{'search': 'name=email_subject_prefix'})[0]
assert email_subject_prefix_value == email_subject_prefix['value']
def test_negative_add_puppet_repo_to_composite(session):
"""Attempt to associate puppet repos within a composite content view
:id: 283fa7da-ca40-4ce2-b3c5-da58ae01b8e7
:expectedresults: User cannot create a composite content view that contains
direct puppet repos.
:CaseLevel: Integration
"""
composite_name = gen_string('alpha')
with session:
session.contentview.create({
'name': composite_name,
'composite_view': True,
})
assert session.contentview.search(
composite_name)[0]['Name'] == composite_name
with raises(NavigationTriesExceeded) as context:
session.contentview.add_puppet_module(composite_name, 'httpd')
assert 'failed to reach [AddPuppetModule]' in str(context.value)
def scap_content():
oscap_content_path = settings.oscap.content_path
_, file_name = os.path.split(oscap_content_path)
title = 'rhel-content-{0}'.format(gen_string('alpha'))
ssh.upload_file(
local_file=oscap_content_path,
remote_file="/tmp/{0}".format(file_name)
)
scap_info = make_scapcontent({
'title': title,
'scap-file': '/tmp/{0}'.format(file_name)
})
scap_id = scap_info['id']
scap_info = Scapcontent.info({'id': scap_id}, output_format='json')
scap_profile_id = [
profile['id']
for profile in scap_info['scap-content-profiles']
if OSCAP_PROFILE['common'] in profile['title']
][0]
return scap_id, scap_profile_id
def test_negative_validate_default_value_with_list(self):
"""Test variable is not created for unmatched validator type list.
:id: dc2b6471-99d7-448b-b90a-9675baacbebe
:steps: Attempt to create variable with default value that doesn't
match values from validator list
:expectedresults: Variable is not created for unmatched validator rule.
:CaseImportance: High
"""
with self.assertRaises(CLIReturnCodeError):
SmartVariable.create(
{
'puppet-class': self.puppet_class['name'],
'default-value': gen_string('alphanumeric'),
'validator-type': 'list',
'validator-rule': '5, test',
}
)
def test_positive_add_parameter(self):
"""Parameters can be created in subnet
:id: c1dae6f4-45b1-45db-8529-d7918e41a99b
:steps:
1. Create Subnet with all the details
2. Create subnet parameter with single key and single value
:expectedresults: The parameter should be created in subnet
"""
subnet = entities.Subnet().create()
for name in generate_strings_list():
with self.subTest(name):
value = gen_string('utf8')
subnet_param = entities.Parameter(subnet=subnet.id,
name=name,
value=value).create()
self.assertEqual(subnet_param.name, name)
self.assertEqual(subnet_param.value, value)
