def test_negative_create_with_invalid_host_limit_and_priority():
"""Create a discovery rule with invalid host limit and priority
:id: e3c7acb1-ac56-496b-ac04-2a83f66ec290
:expectedresults: Validation error should be raised
"""
with pytest.raises(HTTPError):
entities.DiscoveryRule(max_count=gen_string('alpha')).create()
with pytest.raises(HTTPError):
entities.DiscoveryRule(priority=gen_string('alpha')).create()
def test_negative_delete_with_discovery_rule(session, module_org, module_loc):
"""Attempt to delete hostgroup which has dependent discovery rule
:id: bd046e9a-f0d0-4110-8f94-fd04193cb3af
:customerscenario: true
:BZ: 1254102
:expectedresults: Hostgroup was not deleted. Informative error message
was shown
:CaseImportance: High
:CaseLevel: Integration
"""
hostgroup = entities.HostGroup(
organization=[module_org], location=[module_loc]).create()
entities.DiscoveryRule(
hostgroup=hostgroup, organization=[module_org], location=[module_loc]).create()
with session:
assert session.hostgroup.search(hostgroup.name)[0]['Name'] == hostgroup.name
# Make an attempt to delete host group that associated with discovery rule
with raises(AssertionError) as context:
session.hostgroup.delete(hostgroup.name)
assert "Cannot delete record because dependent discovery rules exist" in str(
context.value)
assert session.hostgroup.search(hostgroup.name)[0]['Name'] == hostgroup.name
def test_negative_delete_rule_with_non_admin_user(module_loc, module_org,
reader_user, test_name):
"""Delete rule with non-admin user by associating discovery_reader role
:id: 23a7627c-6a9b-493b-871f-698543adf1d2
:expectedresults: User should validation error and rule should not be
deleted successfully.
:CaseLevel: Integration
"""
hg = entities.HostGroup(organization=[module_org]).create()
dr = entities.DiscoveryRule(
hostgroup=hg,
organization=[module_org],
location=[module_loc]
).create()
with Session(
test_name,
user=reader_user.login,
password=reader_user.password
) as session:
with raises(ValueError):
session.discoveryrule.delete(dr.name)
dr_val = session.discoveryrule.read_all()
assert dr.name in [rule['Name'] for rule in dr_val]
def test_positive_view_existing_rule_with_non_admin_user(module_loc,
module_org,
reader_user,
test_name):
"""Existing rule should be viewed to non-admin user by associating
discovery_reader role.
:id: 0f5b0221-43be-47bc-8619-749824c4e54f
:Steps:
1. create a rule with admin user
2. create a non-admin user and assign 'Discovery Reader' role
3. Login with non-admin user
:expectedresults: Rule should be visible to non-admin user.
:CaseLevel: Integration
"""
hg = entities.HostGroup(organization=[module_org]).create()
dr = entities.DiscoveryRule(
hostgroup=hg,
organization=[module_org],
location=[module_loc]
).create()
with Session(
test_name,
user=reader_user.login,
password=reader_user.password
) as session:
dr_val = session.discoveryrule.read_all()
assert dr.name in [rule['Name'] for rule in dr_val]
def test_positive_delete_rule_with_non_admin_user(manager_loc, manager_user,
module_org, test_name):
"""Delete rule with non-admin user by associating discovery_manager role
:id: 7fa56bab-82d7-46c9-a4fa-c44ef173c703
:expectedresults: Rule should be deleted successfully.
:CaseLevel: Integration
"""
hg = entities.HostGroup(organization=[module_org]).create()
dr = entities.DiscoveryRule(
hostgroup=hg,
organization=[module_org],
location=[manager_loc]
).create()
with Session(
test_name,
user=manager_user.login,
password=manager_user.password
) as session:
dr_val = session.discoveryrule.read_all()
assert dr.name in [rule['Name'] for rule in dr_val]
session.discoveryrule.delete(dr.name)
dr_val = session.discoveryrule.read_all()
assert dr.name not in [rule['Name'] for rule in dr_val]
def test_positive_end_to_end_crud(module_org, module_location,
module_hostgroup):
"""Create a new discovery rule with several attributes, update them
and delete the rule itself.
:id: 25366930-b7f4-4db8-a9c3-a470fe4f3583
:expectedresults: Rule should be created, modified and deleted successfully
with given attributes.
:CaseImportance: Critical
"""
# Create discovery rule
searches = [
'CPU_Count = 1',
'disk_count < 5',
'memory > 500',
'model = KVM',
'Organization = Default_Organization',
]
name = gen_choice(list(valid_data_list().values()))
search = gen_choice(searches)
hostname = 'myhost-<%= rand(99999) %>'
discovery_rule = entities.DiscoveryRule(
name=name,
search_=search,
hostname=hostname,
organization=[module_org],
location=[module_location],
hostgroup=module_hostgroup,
).create()
assert name == discovery_rule.name
assert hostname == discovery_rule.hostname
assert search == discovery_rule.search_
assert module_org.name == discovery_rule.organization[0].read().name
assert module_location.name == discovery_rule.location[0].read().name
assert discovery_rule.enabled is True
# Update discovery rule
name = gen_choice(list(valid_data_list().values()))
search = 'Location = Default_Location'
max_count = gen_integer(1, 100)
enabled = False
discovery_rule.name = name
discovery_rule.search_ = search
discovery_rule.max_count = max_count
discovery_rule.enabled = enabled
discovery_rule = discovery_rule.update(
['name', 'search_', 'max_count', 'enabled'])
assert name == discovery_rule.name
assert search == discovery_rule.search_
assert max_count == discovery_rule.max_count
assert enabled == discovery_rule.enabled
# Delete discovery rule
discovery_rule.delete()
with pytest.raises(HTTPError):
discovery_rule.read()
def setUpClass(cls):
"""Creates two non-admin users with discovery Manager/Reader roles"""
super(DiscoveryRuleRoleTestCase, cls).setUpClass()
cls.per_page = entities.Setting().search(
query={'search': 'name="entries_per_page"'})[0]
cls.saved_per_page = str(cls.per_page.value)
cls.per_page.value = '100000'
cls.per_page.update({'value'})
cls.org = entities.Organization().create()
cls.loc = entities.Location().create()
cls.manager_loc = entities.Location().create()
cls.host_group = entities.HostGroup(
organization=[cls.org]).create()
# Create a discovery rule
cls.rule_name = gen_string('alpha')
entities.DiscoveryRule(
name=cls.rule_name,
hostgroup=cls.host_group,
search_='cpu_count = 1',
organization=[cls.org],
location=[cls.loc],
).create()
# create non-admin reader user with Discovery_Reader role
reader_role = entities.Role().search(
query={'search': 'name="Discovery Reader"'}
)[0]
cls.reader_user = gen_string('alpha')
cls.reader_user_password = gen_string('alphanumeric')
cls.read_user = entities.User(
login=cls.reader_user,
role=[reader_role],
password=cls.reader_user_password,
organization=[cls.org],
location=[cls.loc],
default_organization=cls.org,
default_location=cls.loc,
).create()
# create non-admin manager user with Discovery_Manager role
manager_role = entities.Role().search(
query={'search': 'name="Discovery Manager"'}
)[0]
cls.manager_user = gen_string('alpha')
cls.manager_user_password = gen_string('alphanumeric')
cls.manage_user = entities.User(
login=cls.manager_user,
role=[manager_role],
password=cls.manager_user_password,
organization=[cls.org],
location=[cls.loc, cls.manager_loc],
default_organization=cls.org,
).create()
def test_positive_update(session, module_loc, module_org):
hg = entities.HostGroup(organization=[module_org]).create()
dr = entities.DiscoveryRule(
hostgroup=hg,
organization=[module_org]
).create()
with session:
session.organization.select(org_name=module_org.name)
session.discoveryrule.update(
dr.name, {'locations.resources.assigned': [module_loc.name]})
dr_val = session.discoveryrule.read(dr.name)
assert dr_val[
'locations']['resources']['assigned'][0] == module_loc.name
def test_positive_delete(session, module_org):
hg = entities.HostGroup(organization=[module_org]).create()
dr = entities.DiscoveryRule(
hostgroup=hg,
organization=[module_org]
).create()
with session:
session.organization.select(org_name=module_org.name)
dr_val = session.discoveryrule.read_all()
assert dr.name in [rule['Name'] for rule in dr_val]
session.discoveryrule.delete(dr.name)
dr_val = session.discoveryrule.read_all()
assert dr.name not in [rule['Name'] for rule in dr_val]
def test_positive_disable_and_enable(session, module_org):
hg = entities.HostGroup(organization=[module_org]).create()
dr = entities.DiscoveryRule(
hostgroup=hg,
organization=[module_org]
).create()
with session:
session.organization.select(org_name=module_org.name)
# enable checkbox is true, by default
session.discoveryrule.disable(dr.name)
dr_val = session.discoveryrule.read(dr.name)
assert (not dr_val['primary']['enabled'])
session.discoveryrule.enable(dr.name)
dr_val = session.discoveryrule.read(dr.name)
assert dr_val['primary']['enabled']
def test_positive_create_with_org_loc(self):
"""Create discovery rule by associating org and location
@id: 121e0a30-8a24-47d7-974d-998886ed1ea7
@Assert: Rule was created and with given org & location.
"""
org = entities.Organization().create()
loc = entities.Location().create()
hostgroup = entities.HostGroup(organization=[org]).create()
discovery_rule = entities.DiscoveryRule(
hostgroup=hostgroup,
search_='cpu_count = 1',
organization=[org],
location=[loc],
).create()
self.assertEqual(org.name, discovery_rule.organization[0].read().name)
self.assertEqual(loc.name, discovery_rule.location[0].read().name)
def test_positive_auto_provision_host_with_rule(session, discovery_org,
discovery_location,
module_host_group):
"""Create a new discovery rule and automatically create host from discovered host using that
discovery rule.
Set query as (e.g IP=IP_of_discovered_host)
:id: 4488ab9a-d462-4a62-a1a1-e5656c8a8b99
:Setup: Host should already be discovered
:expectedresults: Host should reboot and provision
:BZ: 1665471, 1731112
:CaseImportance: High
"""
host_ip = gen_ipaddr()
discovered_host_name = create_discovered_host(ip_address=host_ip)['name']
domain = module_host_group.domain.read()
discovery_rule = entities.DiscoveryRule(
max_count=1,
hostgroup=module_host_group,
search_=f'ip = {host_ip}',
location=[discovery_location],
organization=[discovery_org],
).create()
with session:
session.discoveredhosts.apply_action('Auto Provision',
[discovered_host_name])
host_name = f'{discovered_host_name}.{domain.name}'
assert session.host.search(host_name)[0]['Name'] == host_name
host_values = session.host.get_details(host_name)
assert host_values['properties']['properties_table']['Status'] == 'OK'
assert host_values['properties']['properties_table'][
'IP Address'] == host_ip
assert (
host_values['properties']['properties_table']['Comment'] ==
f"Auto-discovered and provisioned via rule '{discovery_rule.name}'"
)
assert not session.discoveredhosts.search(
f'name = {discovered_host_name}')
def setUp(self):
"""Instantiate a ``DiscoveryRule`` and give it several default attrs.
Instantiate a ``DiscoveryRule`` object in memory, but do not create it
on the Satellite server. This allows the object to be customized. Save
it as ``self.discovery_rule``, set its ``hostgroup`` and ``search_``
fields, and give its ``hostname`` field a default value.
"""
searches = [
'CPU_Count = 1',
'disk_count < 5',
'memory > 500',
'model = KVM',
'Organization = Default_Organization',
]
self.discovery_rule = entities.DiscoveryRule(
hostgroup=self.hostgroup,
search_=gen_choice(searches),
)
self.discovery_rule._fields['hostname'].default = (
'myhost-<%= rand(99999) %>')
def test_negative_delete_with_discovery_rule(self):
"""Attempt to delete hostgroup which has dependent discovery rule
:id: bd046e9a-f0d0-4110-8f94-fd04193cb3af
:customerscenario: true
:BZ: 1254102
:expectedresults: Hostgroup was not deleted. Informative error message
was shown
:CaseImportance: High
"""
hostgroup = entities.HostGroup(
organization=[self.session_org]).create()
entities.DiscoveryRule(
hostgroup=hostgroup,
organization=[self.session_org],
).create()
with Session(self):
self.hostgroup.search(hostgroup.name)
self.hostgroup.click(common_locators['select_action_dropdown'] %
hostgroup.name)
self.hostgroup.click(common_locators['delete_button'] %
hostgroup.name,
wait_for_ajax=False)
self.hostgroup.handle_alert(True)
error = self.hostgroup.wait_until_element(
common_locators['alert.error'])
self.assertIsNotNone(error)
self.assertEqual(
error.text,
'Error: Cannot delete record because dependent discovery '
'rules exist')
self.assertIsNotNone(self.hostgroup.search(hostgroup.name))
def test_positive_auto_provision_pxe_host(_module_user, module_org,
module_location, discovery_settings,
provisioning_env):
"""Auto provision a pxe-based host by executing discovery rules
:id: c93fd7c9-41ef-4eb5-8042-f72e87e67e10
:parametrized: yes
:Setup: Provisioning should be configured and a host should be
discovered
:Steps: POST /api/v2/discovered_hosts/:id/auto_provision
:expectedresults: Selected Host should be auto-provisioned successfully
:CaseAutomation: Automated
:CaseImportance: Critical
"""
cfg = get_nailgun_config()
if _module_user:
cfg.auth = (_module_user[0].login, _module_user[1])
# open a ssh channel and attach it to foreman-tail output
ssh_client = ssh.get_client()
with ssh_client.invoke_shell() as channel:
channel.send('foreman-tail\r')
with LibvirtGuest() as pxe_host:
discovered_host = _assert_discovered_host(pxe_host,
channel,
user_config=cfg)
# Provision just discovered host
discovered_host.hostgroup = entities.HostGroup(
cfg, id=provisioning_env['hostgroup']['id']).read()
# create a discovery rule that will match hosts MAC address
entities.DiscoveryRule(
name=gen_string('alphanumeric'),
search_=f"mac = {discovered_host.mac}",
organization=[module_org],
location=[module_location],
hostgroup=entities.HostGroup(
cfg, id=provisioning_env['hostgroup']['id']).read(),
).create()
# Auto-provision the host
discovered_host.auto_provision()
# Assertions
provisioned_host = entities.Host(cfg).search(
query={
'search':
'name={}.{}'.format(discovered_host.name,
provisioning_env['domain']['name'])
})[0]
assert provisioned_host.subnet.read(
).name == provisioning_env['subnet']['name']
assert (provisioned_host.operatingsystem.read().ptable[0].read().
name == provisioning_env['ptable']['name'])
assert provisioned_host.operatingsystem.read(
).title == provisioning_env['os']['title']
assert not entities.DiscoveredHost(cfg).search(
query={'search': f'name={discovered_host.name}'})
def test_positive_list_host_based_on_rule_search_query(session, module_org,
module_loc,
module_discovery_env):
"""List all the discovered hosts resolved by given rule's search query
e.g. all discovered hosts with cpu_count = 2, and list rule's associated
hosts.
:id: f7473fa2-7349-42d3-9cdb-f74b55d2f440
:Steps:
1. discovered host with cpu_count = 2
2. Define a rule 'rule1' with search query cpu_count = 2
3. Click on 'Discovered Hosts' from rule1
4. Auto Provision the discovered host
5. Click on 'Associated Hosts' from rule1
:expectedresults:
1. After step 3, the rule's Discovered host should be listed.
2. The rule's Associated Host should be listed.
:BZ: 1731112
"""
ip_address = gen_ipaddr()
cpu_count = gen_integer(2, 10)
rule_search = 'cpu_count = {0}'.format(cpu_count)
# any way create a host to be sure that this org has more than one host
host = entities.Host(organization=module_org, location=module_loc).create()
host_group = entities.HostGroup(
organization=[module_org],
location=[module_loc],
medium=host.medium,
root_pass=gen_string('alpha'),
operatingsystem=host.operatingsystem,
ptable=host.ptable,
domain=host.domain,
architecture=host.architecture,
).create()
discovery_rule = entities.DiscoveryRule(hostgroup=host_group,
search_=rule_search,
organization=[module_org],
location=[module_loc]).create()
discovered_host = create_discovered_host(
ip_address=ip_address, options={'physicalprocessorcount': cpu_count})
# create an other discovered host with an other cpu count
create_discovered_host(options={'physicalprocessorcount': cpu_count + 1})
provisioned_host_name = '{0}.{1}'.format(discovered_host['name'],
host.domain.read().name)
with session:
session.organization.select(org_name=module_org.name)
session.location.select(loc_name=module_loc.name)
values = session.discoveryrule.read_all()
assert discovery_rule.name in [rule['Name'] for rule in values]
values = session.discoveryrule.read_discovered_hosts(
discovery_rule.name)
assert values['searchbox'] == rule_search
assert len(values['table']) == 1
assert values['table'][0]['IP Address'] == ip_address
assert values['table'][0]['CPUs'] == str(cpu_count)
# auto provision the discovered host
session.discoveredhosts.apply_action('Auto Provision',
[discovered_host['name']])
assert not session.discoveredhosts.search('name = "{0}"'.format(
discovered_host['name']))
values = session.discoveryrule.read_associated_hosts(
discovery_rule.name)
assert (values['searchbox'] == 'discovery_rule = "{0}"'.format(
discovery_rule.name))
assert len(values['table']) == 1
assert values['table'][0]['Name'] == provisioned_host_name
values = session.host.get_details(provisioned_host_name)
assert (values['properties']['properties_table']['IP Address'] ==
ip_address)
