def pytest_generate_tests(metafunc):
new_idlist = []
new_argvalues = []
argnames, argvalues, idlist = testgen.provider_by_type(
metafunc, PROVIDER_TYPES, required_fields=['datastores'])
argnames += ['datastore']
for i, argvalue_tuple in enumerate(argvalues):
args = dict(zip(argnames, argvalue_tuple))
datastores = args['provider'].data.get('datastores', {})
if not datastores:
continue
for ds in datastores:
if not ds.get('test_fleece', False):
continue
assert ds.get('type', None) in DATASTORE_TYPES,\
'datastore type must be set to [{}] for smartstate analysis tests'\
.format('|'.join(DATASTORE_TYPES))
argvs = argvalues[i][:]
new_argvalues.append(argvs + [
datastore.Datastore(ds['name'], args['provider'].key,
ds['type'])
])
test_id = '{}-{}'.format(args['provider'].key, ds['type'])
new_idlist.append(test_id)
testgen.parametrize(metafunc,
argnames,
new_argvalues,
ids=new_idlist,
scope="module")
def test_delete_datastore_appear_after_refresh(setup_provider, provider):
""" Tests delete datastore
Metadata:
test_flag: delete_object
"""
data_store = provider.data['remove_test']['datastore']
test_datastore = datastore.Datastore(name=data_store, provider=provider)
details_view = navigate_to(test_datastore, 'Details')
host_count = int(details_view.contents.relationships.get_text_of('Hosts'))
vm_count = int(
details_view.contents.relationships.get_text_of('Managed VMs'))
if host_count != "0":
test_datastore.delete_all_attached_hosts()
if vm_count != "0":
test_datastore.delete_all_attached_vms()
test_datastore.delete(cancel=False)
wait_for(lambda: not test_datastore.exists,
fail_condition=False,
message="Wait datastore to disappear",
num_sec=500,
fail_func=test_datastore.browser.refresh)
provider.refresh_provider_relationships()
wait_for(lambda: test_datastore.exists,
fail_condition=False,
message="Wait datastore to appear",
num_sec=1000,
fail_func=test_datastore.browser.refresh)
def test_delete_datastore_appear_after_refresh(setup_provider, provider):
""" Tests delete datastore
Metadata:
test_flag: delete_object
"""
data_store = provider.data['remove_test']['datastore']
test_datastore = datastore.Datastore(name=data_store)
host_count = test_datastore.get_detail('Relationships', 'Hosts')
vm_count = test_datastore.get_detail('Relationships', 'Managed VMs')
if host_count != "0":
test_datastore.delete_all_attached_hosts()
test_datastore.wait_for_delete_all()
if vm_count != "0":
test_datastore.delete_all_attached_vms()
test_datastore.wait_for_delete_all()
test_datastore.delete(cancel=False)
test_datastore.wait_for_delete()
provider.refresh_provider_relationships()
test_datastore.wait_for_appear()
def test_delete_datastore(setup_provider, provider, remove_test):
""" Tests delete datastore
Metadata:
test_flag: delete_object
"""
data_store = remove_test['datastore']
test_datastore = datastore.Datastore(name=data_store)
host_count = len(test_datastore.get_hosts())
vm_count = len(test_datastore.get_vms())
if host_count != 0:
test_datastore.delete_all_attached_hosts()
test_datastore.wait_for_delete_all()
if vm_count != 0:
test_datastore.delete_all_attached_vms()
test_datastore.wait_for_delete_all()
test_datastore.delete(cancel=False)
test_datastore.wait_for_delete()
provider.refresh_provider_relationships()
test_datastore.wait_for_appear()
def test_run_datastore_analysis(request, provider_key, datastore_type,
datastore_name):
""" Run host SmartState analysis
"""
test_datastore = datastore.Datastore(datastore_name, provider_key)
# Check if there is a host with valid credentials
host_qis = test_datastore.get_hosts()
assert len(host_qis) != 0, "No hosts attached to this datastore found"
for host_qi in host_qis:
if host_qi.creds == 'checkmark':
break
else:
# If not, get credentials for one of the present hosts
found_host = False
for host_qi in host_qis:
host_data = get_host_data_by_name(provider_key, host_qi._name)
if host_data is None:
continue
found_host = True
test_host = host.Host(name=host_qi._name)
# Add them to the host
wait_for(lambda: test_host.exists,
delay=10,
num_sec=120,
fail_func=sel.refresh)
if not test_host.has_valid_credentials:
test_host.update(
updates={
'credentials':
host.get_credentials_from_config(
host_data['credentials'])
})
wait_for(lambda: test_host.has_valid_credentials,
delay=10,
num_sec=120,
fail_func=sel.refresh)
# And remove them again when the test is finished
def test_host_remove_creds():
test_host.update(
updates={
'credentials':
host.Host.Credential(
principal="", secret="", verify_secret="")
})
request.addfinalizer(test_host_remove_creds)
break
assert found_host,\
"No credentials found for any of the hosts attached to datastore {}"\
.format(datastore_name)
# TODO add support for events
# register_event(
# None,
# "datastore",
# datastore_name,
# ["datastore_analysis_request_req", "datastore_analysis_complete_req"]
# )
# Initiate analysis
sel.force_navigate('infrastructure_datastore',
context={
'datastore': test_datastore,
'provider': test_datastore.provider
})
tb.select('Configuration',
'Perform SmartState Analysis',
invokes_alert=True)
sel.handle_alert()
flash.assert_message_contain(
'"{}": scan successfully initiated'.format(datastore_name))
# Wait for the task to finish
def is_datastore_analysis_finished():
""" Check if analysis is finished - if not, reload page
"""
if not sel.is_displayed(tasks.tasks_table) or not tabs.is_tab_selected(
'All Other Tasks'):
sel.force_navigate('tasks_all_other')
host_analysis_finished = tasks.tasks_table.find_row_by_cells({
'task_name':
"SmartState Analysis for [{}]".format(datastore_name),
'state':
'Finished'
})
return host_analysis_finished is not None
wait_for(is_datastore_analysis_finished,
delay=10,
num_sec=300,
fail_func=lambda: tb.select('Reload'))
# Delete the task
tasks.tasks_table.select_row_by_cells({
'task_name':
"SmartState Analysis for [{}]".format(datastore_name),
'state':
'Finished'
})
tb.select('Delete Tasks', 'Delete', invokes_alert=True)
sel.handle_alert()
# Check results of the analysis and the datastore type
assert test_datastore.get_detail('Properties', 'Datastore Type') == datastore_type.upper(),\
'Datastore type does not match the type defined in yaml'
for row_name in CONTENT_ROWS_TO_CHECK:
assert test_datastore.get_detail('Content', row_name) != '0',\
'{} in Content infoblock should not be 0'.format(row_name)
def test_ssa_template(request, local_setup_provider, provider, soft_assert,
vm_analysis_data):
""" Tests SSA can be performed on a template
Metadata:
test_flag: vm_analysis
"""
template_name = vm_analysis_data['image']
template = Template.factory(template_name, provider, template=True)
# Set credentials to all hosts set for this datastore
if provider.type in ['virtualcenter', 'rhevm']:
datastore_name = vm_analysis_data['datastore']
test_datastore = datastore.Datastore(datastore_name, provider.key)
host_list = cfme_data.get('management_systems',
{})[provider.key].get('hosts', [])
host_names = test_datastore.get_hosts()
for host_name in host_names:
test_host = host.Host(name=host_name, provider=provider)
hosts_data = [x for x in host_list if x.name == host_name]
if len(hosts_data) > 0:
host_data = hosts_data[0]
if not test_host.has_valid_credentials:
creds = host.get_credentials_from_config(
host_data['credentials'])
test_host.update(updates={'credentials': creds},
validate_credentials=True)
template.smartstate_scan()
wait_for(lambda: is_vm_analysis_finished(template_name),
delay=15,
timeout="35m",
fail_func=lambda: toolbar.select('Reload'))
# Check release and quadricon
quadicon_os_icon = template.find_quadicon().os
details_os_icon = template.get_detail(properties=('Properties',
'Operating System'),
icon_href=True)
logger.info("Icons: {}, {}".format(details_os_icon, quadicon_os_icon))
# We shouldn't use get_detail anymore - it takes too much time
c_users = InfoBlock.text('Security', 'Users')
c_groups = InfoBlock.text('Security', 'Groups')
c_packages = 0
if vm_analysis_data['fs-type'] not in ['ntfs', 'fat32']:
c_packages = InfoBlock.text('Configuration', 'Packages')
logger.info("SSA shows {} users, {} groups and {} packages".format(
c_users, c_groups, c_packages))
if vm_analysis_data['fs-type'] not in ['ntfs', 'fat32']:
soft_assert(c_users != '0', "users: '{}' != '0'".format(c_users))
soft_assert(c_groups != '0', "groups: '{}' != '0'".format(c_groups))
soft_assert(c_packages != '0',
"packages: '{}' != '0'".format(c_packages))
else:
# Make sure windows-specific data is not empty
c_patches = InfoBlock.text('Security', 'Patches')
c_applications = InfoBlock.text('Configuration', 'Applications')
c_win32_services = InfoBlock.text('Configuration', 'Win32 Services')
c_kernel_drivers = InfoBlock.text('Configuration', 'Kernel Drivers')
c_fs_drivers = InfoBlock.text('Configuration', 'File System Drivers')
soft_assert(c_patches != '0', "patches: '{}' != '0'".format(c_patches))
soft_assert(c_applications != '0',
"applications: '{}' != '0'".format(c_applications))
soft_assert(c_win32_services != '0',
"win32 services: '{}' != '0'".format(c_win32_services))
soft_assert(c_kernel_drivers != '0',
"kernel drivers: '{}' != '0'".format(c_kernel_drivers))
soft_assert(c_fs_drivers != '0',
"fs drivers: '{}' != '0'".format(c_fs_drivers))
def test_run_datastore_analysis(request, setup_provider, provider,
datastore_type, datastore_name, soft_assert):
"""Tests smarthost analysis
Metadata:
test_flag: datastore_analysis
"""
test_datastore = datastore.Datastore(datastore_name, provider.key)
# Check if there is a host with valid credentials
host_names = test_datastore.get_hosts()
assert len(host_names) != 0, "No hosts attached to this datastore found"
for host_name in host_names:
host_qi = Quadicon(host_name, 'host')
if host_qi.creds == 'checkmark':
break
else:
# If not, get credentials for one of the present hosts
found_host = False
for host_name in host_names:
host_data = get_host_data_by_name(provider.key, host_name)
if host_data is None:
continue
found_host = True
test_host = host.Host(name=host_name)
# Add them to the host
wait_for(lambda: test_host.exists,
delay=10,
num_sec=120,
fail_func=sel.refresh)
if not test_host.has_valid_credentials:
test_host.update(
updates={
'credentials':
host.get_credentials_from_config(
host_data['credentials'])
})
wait_for(lambda: test_host.has_valid_credentials,
delay=10,
num_sec=120,
fail_func=sel.refresh)
# And remove them again when the test is finished
def test_host_remove_creds():
test_host.update(
updates={
'credentials':
host.Host.Credential(
principal="", secret="", verify_secret="")
})
request.addfinalizer(test_host_remove_creds)
break
assert found_host,\
"No credentials found for any of the hosts attached to datastore {}"\
.format(datastore_name)
# TODO add support for events
# register_event(
# None,
# "datastore",
# datastore_name,
# ["datastore_analysis_request_req", "datastore_analysis_complete_req"]
# )
# Initiate analysis
test_datastore.run_smartstate_analysis()
wait_for(lambda: is_datastore_analysis_finished(datastore_name),
delay=15,
timeout="10m",
fail_func=lambda: toolbar.select('Reload'))
c_datastore = test_datastore.get_detail('Properties', 'Datastore Type')
# Check results of the analysis and the datastore type
soft_assert(
c_datastore == datastore_type.upper(),
'Datastore type does not match the type defined in yaml:' +
'expected "{}" but was "{}"'.format(datastore_type.upper(),
c_datastore))
for row_name in CONTENT_ROWS_TO_CHECK:
value = InfoBlock('Content', row_name).text
soft_assert(value != '0',
'Expected value for {} to be non-empty'.format(row_name))