def pytest_generate_tests(metafunc):
argnames, argvalues, idlist = testgen.providers_by_class(
metafunc, [CloudProvider, InfraProvider],
required_fields=['vm_analysis_new'])
argnames.append('analysis_type')
new_idlist = []
new_argvalues = []
for index, argvalue_tuple in enumerate(argvalues):
args = dict(list(zip(argnames, argvalue_tuple)))
vma_data = args['provider'].data.vm_analysis_new
if 'vms' in vma_data:
vms = vma_data.vms
for vm_analysis_key in vms:
# Set VM name here
new_idlist.append('{}-{}'.format(idlist[index],
vm_analysis_key))
new_argvalues.append([args["provider"], vm_analysis_key])
else:
# TODO FIXME
logger.error(
"Provider %s does not have the correct keys in the yaml",
args['provider'].name)
continue
testgen.parametrize(metafunc,
argnames,
new_argvalues,
ids=new_idlist,
scope="module")
def pytest_generate_tests(metafunc):
argnames, argvalues, idlist = testgen.all_providers(metafunc)
testgen.parametrize(metafunc,
argnames,
argvalues,
ids=idlist,
scope="module")
def pytest_generate_tests(metafunc):
types = [VMwareProvider, RHEVMProvider, SCVMMProvider]
argnames, argvalues, idlist = testgen.providers_by_class(
metafunc, types)
argnames = ['providers_for_discover', 'start_ip', 'max_range']
new_id_list = []
providers_complete = []
providers_final = []
for x in idlist:
providers_complete.append(get_crud(x))
provider_combinations = sorted(
find_neighbour_provider_combinations(providers_complete, len(types)), key=len)
signatures_seen = set()
for prov_comb in provider_combinations:
sig = generate_signature(prov_comb)
if sig in signatures_seen:
continue
signatures_seen.add(sig)
start_ip, max_range = minmax_ip(prov_comb)
providers_final.append([prov_comb, start_ip, max_range])
new_id_list.append(sig)
testgen.parametrize(metafunc, argnames, providers_final, ids=new_id_list, scope="module")
def pytest_generate_tests(metafunc):
argnames, argvalues, idlist = testgen.providers_by_class(
metafunc, [RHEVMProvider, VMwareProvider],
required_fields=['datastores'])
argnames.append('datastore_type')
argnames.append('datastore_name')
new_idlist = []
new_argvalues = []
for index, argvalue_tuple in enumerate(argvalues):
args = dict(list(zip(argnames, argvalue_tuple)))
provider_arg = args["provider"]
datastores = provider_arg.data.get("datastores", {})
# don't collect any datastores without test_fleece set
# only collect datastores with type matching accepted list
testable_datastores = [(ds.get("type"), ds.get("name"))
for ds in datastores
if ds.get('test_fleece', False)
and ds.get("type") in DATASTORE_TYPES]
for ds_type, ds_name in testable_datastores:
new_argvalues.append([provider_arg, ds_type, ds_name])
new_idlist.append(f"{idlist[index]}-{ds_type}")
else:
logger.warning(
f"No testable datastores found for SSA on {provider_arg}")
testgen.parametrize(metafunc,
argnames,
new_argvalues,
ids=new_idlist,
scope="module")
def pytest_generate_tests(metafunc):
new_idlist = []
new_argvalues = []
argnames, argvalues, idlist = testgen.providers_by_class(
metafunc, PROVIDER_TYPES, required_fields=['datastores'])
argnames += ['datastore']
appliance = get_or_create_current_appliance()
# TODO: turn the datastore into a parameterized fixture by type,
# and discuss semantics for obtaining them by type
datastore_collection = datastore.DatastoreCollection(appliance)
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') 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_collection.instantiate(
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 pytest_generate_tests(metafunc):
argnames, argvalues, idlist = testgen.providers_by_class(
metafunc, [InfraProvider], required_fields=['hosts'])
argnames = argnames + ['host_type', 'host_name']
new_argvalues = []
new_idlist = []
for index, argvalue_tuple in enumerate(argvalues):
args = dict(zip(argnames, argvalue_tuple))
prov_hosts = args['provider'].data.hosts
for test_host in prov_hosts:
if not test_host.get('test_fleece', False):
continue
assert test_host.get('type') in HOST_TYPES, (
'host type must be set to [{}] for smartstate analysis tests'.
format('|'.join(HOST_TYPES)))
argvalues[index] = argvalues[index] + [
test_host['type'], test_host['name']
]
test_id = '{}-{}'.format(args['provider'].key, test_host['type'])
new_argvalues.append(argvalues[index])
new_idlist.append(test_id)
testgen.parametrize(metafunc,
argnames,
new_argvalues,
ids=new_idlist,
scope="module")
def pytest_generate_tests(metafunc):
new_idlist = []
new_argvalues = []
argnames, argvalues, idlist = testgen.providers_by_class(
metafunc, PROVIDER_TYPES, required_fields=['datastores'])
argnames += ['datastore']
appliance = get_or_create_current_appliance()
# TODO: turn the datastore into a parameterized fixture by type,
# and discuss semantics for obtaining them by type
datastore_collection = datastore.DatastoreCollection(appliance)
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') 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_collection.instantiate(
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 pytest_generate_tests(metafunc):
# Filter out providers without provisioning data or hosts defined
argnames, argvalues, idlist = testgen.providers_by_class(
metafunc, [InfraProvider],
required_fields=[
'iso_datastore',
['provisioning', 'host'],
['provisioning', 'datastore'],
['provisioning', 'iso_template'],
['provisioning', 'iso_file'],
['provisioning', 'iso_kickstart'],
['provisioning', 'iso_root_password'],
['provisioning', 'iso_image_type'],
['provisioning', 'vlan'],
])
new_idlist = []
new_argvalues = []
for i, argvalue_tuple in enumerate(argvalues):
args = dict(zip(argnames, argvalue_tuple))
iso_cust_template = args['provider'].data['provisioning'][
'iso_kickstart']
if iso_cust_template not in cfme_data.get('customization_templates',
{}).keys():
continue
new_idlist.append(idlist[i])
new_argvalues.append(argvalues[i])
testgen.parametrize(metafunc,
argnames,
new_argvalues,
ids=new_idlist,
scope="module")
def pytest_generate_tests(metafunc):
# Filter out providers without provisioning data or hosts defined
argnames, argvalues, idlist = testgen.providers_by_class(
metafunc, [InfraProvider], required_fields=[
'iso_datastore',
['provisioning', 'host'],
['provisioning', 'datastore'],
['provisioning', 'iso_template'],
['provisioning', 'iso_file'],
['provisioning', 'iso_kickstart'],
['provisioning', 'iso_root_password'],
['provisioning', 'iso_image_type'],
['provisioning', 'vlan'],
])
new_idlist = []
new_argvalues = []
for i, argvalue_tuple in enumerate(argvalues):
args = dict(zip(argnames, argvalue_tuple))
iso_cust_template = args['provider'].data['provisioning']['iso_kickstart']
if iso_cust_template not in cfme_data.get('customization_templates', {}).keys():
continue
new_idlist.append(idlist[i])
new_argvalues.append(argvalues[i])
testgen.parametrize(metafunc, argnames, new_argvalues, ids=new_idlist, scope="module")
def pytest_generate_tests(metafunc):
types = [VMwareProvider, RHEVMProvider, SCVMMProvider]
argnames, argvalues, idlist = testgen.providers_by_class(metafunc, types)
argnames = ['providers_for_discover', 'start_ip', 'max_range']
new_id_list = []
providers_complete = []
providers_final = []
for x in idlist:
providers_complete.append(get_crud(x))
provider_combinations = sorted(find_neighbour_provider_combinations(
providers_complete, len(types)),
key=len)
signatures_seen = set()
for prov_comb in provider_combinations:
sig = generate_signature(prov_comb)
if sig in signatures_seen:
continue
signatures_seen.add(sig)
start_ip, max_range = minmax_ip(prov_comb)
providers_final.append([prov_comb, start_ip, max_range])
new_id_list.append(sig)
testgen.parametrize(metafunc,
argnames,
providers_final,
ids=new_id_list,
scope="module")
def pytest_generate_tests(metafunc):
argnames, argvalues, idlist = testgen.providers_by_class(metafunc, [InfraProvider],
required_fields=['hosts'])
argnames = argnames + ['host_type', 'host_name']
new_argvalues = []
new_idlist = []
for index, argvalue_tuple in enumerate(argvalues):
args = dict(zip(argnames, argvalue_tuple))
prov_hosts = args['provider'].data.hosts
for test_host in prov_hosts:
if not test_host.get('test_fleece', False):
continue
if test_host.get('type') not in HOST_TYPES:
logger.warning('host type must be set to [{}] for smartstate analysis tests'
.format('|'.join(HOST_TYPES)))
continue
new_argvalue_list = [args['provider'], test_host['type'], test_host['name']]
test_id = '{}-{}-{}'.format(args['provider'].key, test_host['type'], test_host['name'])
new_argvalues.append(new_argvalue_list)
new_idlist.append(test_id)
testgen.parametrize(metafunc, argnames, new_argvalues, ids=new_idlist, scope="module")
def pytest_generate_tests(metafunc):
argnames, argvalues, idlist = testgen.providers_by_class(metafunc, [InfraProvider])
argnames = argnames + ['host_type', 'host_name']
new_argvalues = []
new_idlist = []
for i, argvalue_tuple in enumerate(argvalues):
args = dict(zip(argnames, argvalue_tuple))
prov_hosts = args['provider'].data.get('hosts')
if not prov_hosts:
continue
for test_host in prov_hosts:
if not test_host.get('test_fleece', False):
continue
assert test_host.get('type') in HOST_TYPES,\
'host type must be set to [{}] for smartstate analysis tests'\
.format('|'.join(HOST_TYPES))
argvalues[i] = argvalues[i] + [test_host['type'], test_host['name']]
test_id = '{}-{}-{}'.format(args['provider'].key, test_host['type'], test_host['name'])
new_argvalues.append(argvalues[i])
new_idlist.append(test_id)
testgen.parametrize(metafunc, argnames, new_argvalues, ids=new_idlist, scope="module")
def pytest_generate_tests(metafunc):
argnames, argvalues, idlist = testgen.providers_by_class(
metafunc, [RHEVMProvider, VMwareProvider],
required_fields=['datastores'])
argnames.append('datastore_type')
new_idlist = []
new_argvalues = []
for index, argvalue_tuple in enumerate(argvalues):
args = dict(zip(argnames, argvalue_tuple))
datastores = args['provider'].data.datastores
for ds in datastores:
if not ds.get('test_fleece', False):
continue
assert ds['type'] in DATASTORE_TYPES, (
'datastore type must be set to [{}] for smartstate analysis tests'
.format('|'.join(DATASTORE_TYPES)))
new_argvalues.append([args["provider"], ds['type']])
test_id = '{}-{}'.format(idlist[index], ds['type'])
new_idlist.append(test_id)
testgen.parametrize(metafunc,
argnames,
new_argvalues,
ids=new_idlist,
scope="module")
def pytest_generate_tests(metafunc):
argnames, argvalues, idlist = testgen.providers_by_class(
metafunc, [VMwareProvider])
argnames = argnames + ["_host_provider"]
new_idlist = []
new_argvalues = []
for i, argvalue_tuple in enumerate(argvalues):
args = dict(zip(argnames, argvalue_tuple))
# TODO
# All this should be replaced with a proper ProviderFilter passed to testgen.providers()
if args['provider'].type != "virtualcenter":
continue
hosts = args['provider'].data.get("hosts", [])
if not hosts:
continue
version = args['provider'].data.get("version")
if version is None:
# No version, no test
continue
if Version(version) < "5.0":
# Ignore lesser than 5
continue
host = hosts[0]
ip_address = resolve_hostname(host["name"])
endpoint = VirtualCenterEndpoint(
credentials=host["credentials"]["default"],
hostname=host["name"],
ip_address=ip_address)
# Mock provider data
provider_data = {}
provider_data.update(args['provider'].data)
provider_data["name"] = host["name"]
provider_data["hostname"] = host["name"]
provider_data["ipaddress"] = ip_address
provider_data.pop("host_provisioning", None)
provider_data["hosts"] = [host]
provider_data["discovery_range"] = {}
provider_data["discovery_range"]["start"] = ip_address
provider_data["discovery_range"]["end"] = ip_address
appliance = find_appliance(metafunc, require=False)
host_provider = appliance.collections.infra_providers.instantiate(
prov_class=VMwareProvider,
name=host["name"],
endpoints=endpoint,
provider_data=provider_data)
argvalues[i].append(host_provider)
idlist[i] = "{}/{}".format(args['provider'].key, host["name"])
new_idlist.append(idlist[i])
new_argvalues.append(argvalues[i])
testgen.parametrize(metafunc,
argnames,
new_argvalues,
ids=new_idlist,
scope="module")
def pytest_generate_tests(metafunc):
argnames, argvalues, idlist = testgen.providers_by_class(
metafunc, [VMwareProvider, OpenStackProvider])
testgen.parametrize(metafunc,
argnames,
argvalues,
ids=idlist,
scope='module')
def pytest_generate_tests(metafunc):
argnames, argvalues, idlist = testgen.all_providers(
metafunc, required_fields=['provisioning'])
testgen.parametrize(metafunc,
argnames,
argvalues,
ids=idlist,
scope="module")
def pytest_generate_tests(metafunc):
argnames, argvalues, idlist = testgen.providers_by_class(
metafunc, [VMwareProvider],
required_fields=[['provisioning', 'template']])
testgen.parametrize(metafunc,
argnames,
argvalues,
ids=idlist,
scope='module')
def pytest_generate_tests(metafunc):
# Filter out providers without host provisioning data defined
argnames, argvalues, idlist = testgen.providers_by_class(
metafunc, [InfraProvider],
required_fields=[
['host_provisioning', 'pxe_server'],
['host_provisioning', 'pxe_image'],
['host_provisioning', 'pxe_image_type'],
['host_provisioning', 'pxe_kickstart'],
['host_provisioning', 'datacenter'],
['host_provisioning', 'cluster'],
['host_provisioning', 'datastores'],
['host_provisioning', 'hostname'],
['host_provisioning', 'root_password'],
['host_provisioning', 'ip_addr'],
['host_provisioning', 'subnet_mask'],
['host_provisioning', 'gateway'],
['host_provisioning', 'dns'],
])
pargnames, pargvalues, pidlist = testgen.pxe_servers(metafunc)
argnames = argnames + ['pxe_server', 'pxe_cust_template']
pxe_server_names = [pval[0] for pval in pargvalues]
new_idlist = []
new_argvalues = []
for i, argvalue_tuple in enumerate(argvalues):
args = dict(zip(argnames, argvalue_tuple))
try:
prov_data = args['provider'].data['host_provisioning']
except KeyError:
# No host provisioning data available
continue
stream = prov_data.get('runs_on_stream', '')
if not version.current_version().is_in_series(str(stream)):
continue
pxe_server_name = prov_data.get('pxe_server', '')
if pxe_server_name not in pxe_server_names:
continue
pxe_cust_template = prov_data.get('pxe_kickstart', '')
if pxe_cust_template not in cfme_data.get('customization_templates',
{}).keys():
continue
argvalues[i].append(get_pxe_server_from_config(pxe_server_name))
argvalues[i].append(get_template_from_config(pxe_cust_template))
new_idlist.append(idlist[i])
new_argvalues.append(argvalues[i])
testgen.parametrize(metafunc,
argnames,
new_argvalues,
ids=new_idlist,
scope="module")
def pytest_generate_tests(metafunc):
argnames, argvalues, idlist = testgen.providers_by_class(metafunc, [VMwareProvider])
argnames = argnames + ["_host_provider"]
new_idlist = []
new_argvalues = []
for i, argvalue_tuple in enumerate(argvalues):
args = dict(zip(argnames, argvalue_tuple))
# TODO
# All this should be replaced with a proper ProviderFilter passed to testgen.providers()
if args['provider'].type != "virtualcenter":
continue
hosts = args['provider'].data.get("hosts", [])
if not hosts:
continue
version = args['provider'].data.get("version")
if version is None:
# No version, no test
continue
if Version(version) < "5.0":
# Ignore lesser than 5
continue
host = hosts[0]
ip_address = resolve_hostname(host["name"])
endpoint = VirtualCenterEndpoint(
credentials=host["credentials"]["default"],
hostname=host["name"],
ip_address=ip_address
)
# Mock provider data
provider_data = {}
provider_data.update(args['provider'].data)
provider_data["name"] = host["name"]
provider_data["hostname"] = host["name"]
provider_data["ipaddress"] = ip_address
provider_data.pop("host_provisioning", None)
provider_data["hosts"] = [host]
provider_data["discovery_range"] = {}
provider_data["discovery_range"]["start"] = ip_address
provider_data["discovery_range"]["end"] = ip_address
appliance = find_appliance(metafunc, require=False)
host_provider = appliance.collections.infra_providers.instantiate(
prov_class=VMwareProvider,
name=host["name"],
endpoints=endpoint,
provider_data=provider_data)
argvalues[i].append(host_provider)
idlist[i] = "{}/{}".format(args['provider'].key, host["name"])
new_idlist.append(idlist[i])
new_argvalues.append(argvalues[i])
testgen.parametrize(metafunc, argnames, new_argvalues, ids=new_idlist, scope="module")
def pytest_generate_tests(metafunc):
# Filter out providers without provisioning data or hosts defined
argnames, argvalues, idlist = testgen.providers_by_class(metafunc, [RHEVMProvider],
required_fields=[
['provisioning', 'ci-template'],
['provisioning', 'ci-username'],
['provisioning', 'ci-pass'],
['provisioning', 'image'],
['provisioning', 'vlan']
])
testgen.parametrize(metafunc, argnames, argvalues, ids=idlist, scope="module")
def pytest_generate_tests(metafunc):
argnames, argvalues, idlist = testgen.providers_by_class(
metafunc, [
VMwareProvider, RHEVMProvider, EC2Provider, OpenStackProvider,
AzureProvider, GCEProvider
],
required_fields=[(['cap_and_util', 'capandu_vm'], 'cu-24x7')])
testgen.parametrize(metafunc,
argnames,
argvalues,
ids=idlist,
scope="module")
def pytest_generate_tests(metafunc):
yield
if 'rbac_role' in metafunc.fixturenames:
if enable_rbac:
try:
meta_data = metafunc.function.meta
roles = meta_data.kwargs['from_docs']['rbac']['roles'].keys()
except:
raise Exception("Test {} should have metadata describing RBAC roles")
else:
roles = ['default']
testgen.parametrize(metafunc, 'rbac_role', roles)
def pytest_generate_tests(metafunc):
# Filter out providers without templates defined
argnames, argvalues, idlist = testgen.all_providers(metafunc)
# if metafunc.function is not test_ssa_template:
argnames.append('analysis_type')
new_idlist = []
new_argvalues = []
for i, argvalue_tuple in enumerate(argvalues):
args = dict(zip(argnames, argvalue_tuple))
# if metafunc.function is test_ssa_template:
# new_idlist.append(args['provider'].key)
# new_argvalues.append([args["provider"]])
# continue
vms = []
provisioning_data = []
try:
vma_data = args['provider'].data.get('vm_analysis_new', {})
vms = vma_data.get("vms", {})
provisioning_data = vma_data.get("provisioning", {})
except AttributeError:
# Provider has no provisioning and/or vms list set
continue
for vm_analysis_key in vms:
# Each VM can redefine a provisioning data
vm_analysis_data = provisioning_data.copy()
vm_analysis_data.update(vms[vm_analysis_key])
if not {'image', 'fs-type'}.issubset(vm_analysis_data.viewkeys()):
continue
if vm_analysis_data['fs-type'] not in ['ntfs', 'fat32']:
# Username and password are required for non-windows VMs
if not {'username', 'password'}.issubset(
vm_analysis_data.viewkeys()):
continue
# Set VM name here
new_idlist.append('{}-{}'.format(idlist[i], vm_analysis_key))
new_argvalues.append([args["provider"], vm_analysis_key])
testgen.parametrize(metafunc,
argnames,
new_argvalues,
ids=new_idlist,
scope="module")
def pytest_generate_tests(metafunc):
yield
if 'rbac_role' in metafunc.fixturenames:
if enable_rbac:
try:
meta_data = metafunc.function.meta
roles = meta_data.kwargs['from_docs']['rbac']['roles'].keys()
except:
raise Exception(
"Test {} should have metadata describing RBAC roles")
else:
roles = ['default']
testgen.parametrize(metafunc, 'rbac_role', roles)
def pytest_generate_tests(metafunc):
# Filter out providers without provisioning data or hosts defined
argnames, argvalues, idlist = testgen.config_managers(metafunc)
new_idlist = []
new_argvalues = []
for i, argvalue_tuple in enumerate(argvalues):
args = dict(zip(argnames, argvalue_tuple))
if not args['config_manager_obj'].yaml_data['provisioning']:
continue
new_idlist.append(idlist[i])
new_argvalues.append(argvalues[i])
testgen.parametrize(metafunc, argnames, new_argvalues, ids=new_idlist, scope='module')
def pytest_generate_tests(metafunc):
argnames, argvalues, idlist = testgen.providers_by_class(
metafunc, [CloudInfraProvider], required_fields=['vm_analysis_new'])
argnames.append('analysis_type')
new_idlist = []
new_argvalues = []
for index, argvalue_tuple in enumerate(argvalues):
args = dict(zip(argnames, argvalue_tuple))
vma_data = args['provider'].data.vm_analysis_new
vms = vma_data.vms
for vm_analysis_key in vms:
# Set VM name here
new_idlist.append('{}-{}'.format(idlist[index], vm_analysis_key))
new_argvalues.append([args["provider"], vm_analysis_key])
testgen.parametrize(metafunc, argnames, new_argvalues, ids=new_idlist, scope="module")
def pytest_generate_tests(metafunc):
argnames, argvalues, idlist = testgen.providers_by_class(
metafunc, [CloudInfraProvider], required_fields=['vm_analysis_new'])
argnames.append('analysis_type')
new_idlist = []
new_argvalues = []
for index, argvalue_tuple in enumerate(argvalues):
args = dict(zip(argnames, argvalue_tuple))
vma_data = args['provider'].data.vm_analysis_new
vms = vma_data.vms
for vm_analysis_key in vms:
# Set VM name here
new_idlist.append('{}-{}'.format(idlist[index], vm_analysis_key))
new_argvalues.append([args["provider"], vm_analysis_key])
testgen.parametrize(metafunc, argnames, new_argvalues, ids=new_idlist, scope="module")
def pytest_generate_tests(metafunc):
"""This is parametrizing over the provider types and creating permutations of provider pairs,
adding ids and argvalues."""
argnames1, argvalues1, idlist1 = testgen.providers_by_class(metafunc, [VMwareProvider])
argnames2, argvalues2, idlist2 = testgen.providers_by_class(metafunc, [RHEVMProvider])
new_idlist = []
new_argvalues = []
new_argnames = ['nvc_prov', 'rhvm_prov']
for index1, argvalue_tuple1 in enumerate(argvalues1):
for index2, argvalue_tuple2 in enumerate(argvalues2):
new_idlist.append('{}-{}'.format(idlist1[index1], idlist2[index2]))
new_argvalues.append((argvalue_tuple1[0], argvalue_tuple2[0]))
testgen.parametrize(metafunc, new_argnames, new_argvalues, ids=new_idlist, scope="module")
def pytest_generate_tests(metafunc):
# Filter out providers not meant for Chargeback Testing
argnames, argvalues, idlist = testgen.providers_by_class(
metafunc, [VMwareProvider, RHEVMProvider, AzureProvider, GCEProvider],
required_fields=[(['cap_and_util', 'test_chargeback'], True)]
)
new_argvalues = []
new_idlist = []
for i, argvalue_tuple in enumerate(argvalues):
new_idlist.append(idlist[i])
new_argvalues.append(argvalues[i])
testgen.parametrize(metafunc, argnames, new_argvalues, ids=new_idlist, scope="module")
def pytest_generate_tests(metafunc):
# Filter out providers without provisioning data or hosts defined
argnames, argvalues, idlist = testgen.config_managers(metafunc)
new_idlist = []
new_argvalues = []
for i, argvalue_tuple in enumerate(argvalues):
args = dict(zip(argnames, argvalue_tuple))
if not args['config_manager_obj'].yaml_data['provisioning']:
continue
new_idlist.append(idlist[i])
new_argvalues.append(argvalues[i])
testgen.parametrize(metafunc, argnames, new_argvalues, ids=new_idlist, scope='module')
def pytest_generate_tests(metafunc):
# Filter out providers without host provisioning data defined
argnames, argvalues, idlist = testgen.providers_by_class(
metafunc, [InfraProvider], required_fields=[
['host_provisioning', 'pxe_server'],
['host_provisioning', 'pxe_image'],
['host_provisioning', 'pxe_image_type'],
['host_provisioning', 'pxe_kickstart'],
['host_provisioning', 'datacenter'],
['host_provisioning', 'cluster'],
['host_provisioning', 'datastores'],
['host_provisioning', 'hostname'],
['host_provisioning', 'root_password'],
['host_provisioning', 'ip_addr'],
['host_provisioning', 'subnet_mask'],
['host_provisioning', 'gateway'],
['host_provisioning', 'dns'],
])
pargnames, pargvalues, pidlist = testgen.pxe_servers(metafunc)
pxe_server_names = [pval[0] for pval in pargvalues]
new_idlist = []
new_argvalues = []
for i, argvalue_tuple in enumerate(argvalues):
args = dict(zip(argnames, argvalue_tuple))
try:
prov_data = args['provider'].data['host_provisioning']
except KeyError:
# No host provisioning data available
continue
holder = metafunc.config.pluginmanager.get_plugin('appliance-holder')
stream = prov_data.get('runs_on_stream', '')
if not holder.held_appliance.version.is_in_series(str(stream)):
continue
pxe_server_name = prov_data.get('pxe_server', '')
if pxe_server_name not in pxe_server_names:
continue
pxe_cust_template = prov_data.get('pxe_kickstart', '')
if pxe_cust_template not in cfme_data.get('customization_templates', {}).keys():
continue
new_idlist.append(idlist[i])
new_argvalues.append(argvalues[i])
testgen.parametrize(metafunc, argnames, new_argvalues, ids=new_idlist, scope="module")
def pytest_generate_tests(metafunc):
""" Parametrizes the logdepot tests according to cfme_data YAML file.
YAML structure (shared with db backup tests) is as follows:
log_db_depot:
credentials: credentials_key
protocols:
smb:
path_on_host: /path/on/host
use_for_log_collection: True
use_for_db_backups: False
nfs:
hostname: nfs.example.com/path/on/host
use_for_log_collection: False
use_for_db_backups: True
ftp:
hostname: ftp.example.com
use_for_log_collection: True
"""
if metafunc.function.__name__ == 'test_collect_unconfigured':
return
fixtures = ['log_depot']
data = conf.cfme_data.get("log_db_operations", {})
depots = []
ids = []
if not data:
pytest.skip('No log_db_operations information!')
creds = conf.credentials[data['credentials']]
for protocol, proto_data in data['protocols'].items():
if proto_data['use_for_log_collection']:
depots.append([
LogDepotType(protocol, creds, proto_data.get('sub_folder'),
proto_data.get('path_on_host'))
])
ids.append(protocol)
if metafunc.function.__name__ in [
"test_collect_multiple_servers", "test_collect_single_servers"
]:
ids = ids[:1]
depots = depots[:1]
elif metafunc.function.__name__ == "test_log_collection_over_ipv6":
anon_id = ids.index("anon_ftp")
ids = [ids[anon_id]]
depots = [depots[anon_id]]
testgen.parametrize(metafunc, fixtures, depots, ids=ids, scope="function")
return
def pytest_generate_tests(metafunc):
# Filter out providers without provisioning data or hosts defined
argnames, argvalues, idlist = testgen.providers_by_class(
metafunc, [InfraProvider],
required_fields=[['provisioning', 'pxe_server'],
['provisioning', 'pxe_image'],
['provisioning', 'pxe_image_type'],
['provisioning', 'pxe_kickstart'],
['provisioning', 'pxe_template'],
['provisioning', 'datastore'],
['provisioning', 'host'],
['provisioning', 'pxe_root_password'],
['provisioning', 'vlan']])
pargnames, pargvalues, pidlist = testgen.pxe_servers(metafunc)
argnames = argnames + ['pxe_server', 'pxe_cust_template']
pxe_server_names = [pval[0] for pval in pargvalues]
new_idlist = []
new_argvalues = []
for i, argvalue_tuple in enumerate(argvalues):
args = dict(zip(argnames, argvalue_tuple))
provider = args['provider']
if provider.one_of(SCVMMProvider):
continue
provisioning_data = provider.data['provisioning']
pxe_server_name = provisioning_data['pxe_server']
if pxe_server_name not in pxe_server_names:
continue
pxe_cust_template = provisioning_data['pxe_kickstart']
if pxe_cust_template not in cfme_data.get('customization_templates',
{}).keys():
continue
argvalues[i].append(get_pxe_server_from_config(pxe_server_name))
argvalues[i].append(get_template_from_config(pxe_cust_template))
new_idlist.append(idlist[i])
new_argvalues.append(argvalues[i])
testgen.parametrize(metafunc,
argnames,
new_argvalues,
ids=new_idlist,
scope="module")
def pytest_generate_tests(metafunc):
# Filter out providers without templates defined
argnames, argvalues, idlist = testgen.all_providers(metafunc)
# if metafunc.function is not test_ssa_template:
argnames.append('analysis_type')
new_idlist = []
new_argvalues = []
for i, argvalue_tuple in enumerate(argvalues):
args = dict(zip(argnames, argvalue_tuple))
# if metafunc.function is test_ssa_template:
# new_idlist.append(args['provider'].key)
# new_argvalues.append([args["provider"]])
# continue
vms = []
provisioning_data = []
try:
vma_data = args['provider'].data.get('vm_analysis_new', {})
vms = vma_data.get("vms", {})
provisioning_data = vma_data.get("provisioning", {})
except AttributeError:
# Provider has no provisioning and/or vms list set
continue
for vm_analysis_key in vms:
# Each VM can redefine a provisioning data
vm_analysis_data = provisioning_data.copy()
vm_analysis_data.update(vms[vm_analysis_key])
if not {'image', 'fs-type'}.issubset(
vm_analysis_data.viewkeys()):
continue
if vm_analysis_data['fs-type'] not in ['ntfs', 'fat32']:
# Username and password are required for non-windows VMs
if not {'username', 'password'}.issubset(
vm_analysis_data.viewkeys()):
continue
# Set VM name here
new_idlist.append('{}-{}'.format(idlist[i], vm_analysis_key))
new_argvalues.append([args["provider"], vm_analysis_key])
testgen.parametrize(metafunc, argnames, new_argvalues, ids=new_idlist, scope="module")
def pytest_generate_tests(metafunc):
# Filter out providers without provisioning data or hosts defined
argnames, argvalues, idlist = testgen.providers_by_class(
metafunc, [InfraProvider],
required_fields=[
['provisioning', 'pxe_server'],
['provisioning', 'pxe_image'],
['provisioning', 'pxe_image_type'],
['provisioning', 'pxe_kickstart'],
['provisioning', 'pxe_template'],
['provisioning', 'datastore'],
['provisioning', 'host'],
['provisioning', 'pxe_root_password'],
['provisioning', 'vlan']
]
)
pargnames, pargvalues, pidlist = testgen.pxe_servers(metafunc)
argnames = argnames + ['pxe_server', 'pxe_cust_template']
pxe_server_names = [pval[0] for pval in pargvalues]
new_idlist = []
new_argvalues = []
for i, argvalue_tuple in enumerate(argvalues):
args = dict(zip(argnames, argvalue_tuple))
provider = args['provider']
if provider.one_of(SCVMMProvider):
continue
provisioning_data = provider.data['provisioning']
pxe_server_name = provisioning_data['pxe_server']
if pxe_server_name not in pxe_server_names:
continue
pxe_cust_template = provisioning_data['pxe_kickstart']
if pxe_cust_template not in cfme_data.get('customization_templates', {}).keys():
continue
argvalues[i].append(get_pxe_server_from_config(pxe_server_name))
argvalues[i].append(get_template_from_config(pxe_cust_template))
new_idlist.append(idlist[i])
new_argvalues.append(argvalues[i])
testgen.parametrize(metafunc, argnames, new_argvalues, ids=new_idlist, scope="module")
def pytest_generate_tests(metafunc):
""" Generates DbBackupData fixture called 'db_backup_data' with all the necessary data
"""
data = conf.cfme_data.get('log_db_operations', {})
if 'db_backup_data' in metafunc.fixturenames:
argnames = 'db_backup_data'
argvalues = []
ids = []
machine_data = data["log_db_depot_template"]
for protocol in data["protocols"]:
if protocol in PROTOCOL_TYPES and data["protocols"][protocol].get('use_for_db_backups',
False):
db_backup_data = DbBackupData(machine_data, protocol, data["protocols"][protocol])
argvalues.append(db_backup_data)
ids.append(db_backup_data.id)
testgen.parametrize(metafunc, argnames, argvalues, ids=ids)
def pytest_generate_tests(metafunc):
""" Generates DbBackupData fixture called 'db_backup_data' with all the necessary data
"""
data = conf.cfme_data.get('log_db_operations', {})
if 'db_backup_data' in metafunc.fixturenames:
argnames = 'db_backup_data'
argvalues = []
ids = []
machine_data = data["log_db_depot_template"]
for protocol in data["protocols"]:
if protocol in PROTOCOL_TYPES and data["protocols"][protocol].get('use_for_db_backups',
False):
db_backup_data = DbBackupData(machine_data, protocol, data["protocols"][protocol])
argvalues.append(db_backup_data)
ids.append(db_backup_data.id)
testgen.parametrize(metafunc, argnames, argvalues, ids=ids)
def pytest_generate_tests(metafunc):
# Filter out providers without multiple hosts defined
argnames, argvalues, idlist = testgen.providers_by_class(
metafunc, [InfraProvider], required_fields=["hosts"])
new_argvalues = []
new_idlist = []
for i, argvalue_tuple in enumerate(argvalues):
args = dict(zip(argnames, argvalue_tuple))
hosts = args['provider'].data.get('hosts', {})
if len(hosts) < 2:
continue
new_idlist.append(idlist[i])
new_argvalues.append(argvalues[i])
testgen.parametrize(metafunc, argnames, new_argvalues, ids=new_idlist, scope="module")
def pytest_generate_tests(metafunc):
if metafunc.function in {test_rh_updates}:
return
""" Generates tests specific to RHSM or SAT6 with proxy-on or off """
argnames = ['reg_method', 'reg_data', 'proxy_url', 'proxy_creds']
argvalues = []
idlist = []
try:
holder = metafunc.config.pluginmanager.get_plugin('appliance-holder')
stream = holder.held_appliance.version.stream()
all_reg_data = conf.cfme_data.get('redhat_updates',
{})['streams'][stream]
except KeyError:
logger.warning('Could not find rhsm data for stream in yaml')
pytest.mark.uncollect(
metafunc.function,
message='Could not find rhsm data for stream in yaml')
return
if 'reg_method' in metafunc.fixturenames:
for reg_method in REG_METHODS:
reg_data = all_reg_data.get(reg_method)
if not reg_data or not reg_data.get('test_registration', False):
continue
proxy_data = conf.cfme_data.get('redhat_updates',
{}).get('http_proxy', False)
if proxy_data and reg_data.get('use_http_proxy', False):
proxy_url = proxy_data['url']
proxy_creds_key = proxy_data['credentials']
proxy_creds = conf.credentials[proxy_creds_key]
argval = [reg_method, reg_data, proxy_url, proxy_creds]
argid = '{}-{}'.format(reg_method, 'proxy_on')
idlist.append(argid)
argvalues.append(argval)
argval = [reg_method, reg_data, None, None]
argid = '{}-{}'.format(reg_method, 'proxy_off')
idlist.append(argid)
argvalues.append(argval)
parametrize(metafunc, argnames, argvalues, ids=idlist, scope="module")
def pytest_generate_tests(metafunc):
""" Parametrizes the logdepot tests according to cfme_data YAML file.
YAML structure (shared with db backup tests) is as follows:
log_db_depot:
credentials: credentials_key
protocols:
smb:
path_on_host: /path/on/host
use_for_log_collection: True
use_for_db_backups: False
nfs:
hostname: nfs.example.com/path/on/host
use_for_log_collection: False
use_for_db_backups: True
ftp:
hostname: ftp.example.com
use_for_log_collection: True
"""
if metafunc.function.__name__ == 'test_collect_unconfigured':
return
fixtures = ['log_depot']
data = conf.cfme_data.get("log_db_operations", {})
depots = []
ids = []
if not data:
pytest.skip('No log_db_operations information!')
creds = conf.credentials[data['credentials']]
for protocol, proto_data in data['protocols'].items():
if proto_data['use_for_log_collection']:
depots.append([LogDepotType(
protocol, creds,
proto_data.get('sub_folder'), proto_data.get('path_on_host'))])
ids.append(protocol)
if metafunc.function.__name__ in ['test_collect_multiple_servers',
"test_collect_single_servers"]:
ids = ids[:1]
depots = depots[:1]
testgen.parametrize(metafunc, fixtures, depots, ids=ids, scope="function")
return
def pytest_generate_tests(metafunc):
argnames, argvalues, idlist = testgen.providers_by_class(
metafunc, [InfraProvider], required_fields=['hosts'])
argnames += ['host']
new_idlist = []
new_argvalues = []
for i, argvalue_tuple in enumerate(argvalues):
args = dict(zip(argnames, argvalue_tuple))
for test_host in args['provider'].data['hosts']:
if not test_host.get('test_fleece', False):
continue
argvs = argvalues[i][:]
new_argvalues.append(argvs + [test_host])
test_id = '{}-{}'.format(args['provider'].key, test_host['type'])
new_idlist.append(test_id)
testgen.parametrize(metafunc, argnames, new_argvalues, ids=new_idlist, scope="module")
def pytest_generate_tests(metafunc):
argnames, argvalues, idlist = testgen.providers_by_class(
metafunc, [InfraProvider], required_fields=['hosts'])
argnames += ['host']
new_idlist = []
new_argvalues = []
for i, argvalue_tuple in enumerate(argvalues):
args = dict(zip(argnames, argvalue_tuple))
for test_host in args['provider'].data['hosts']:
if not test_host.get('test_fleece', False):
continue
argvs = argvalues[i][:]
new_argvalues.append(argvs + [test_host])
test_id = '{}-{}'.format(args['provider'].key, test_host['type'])
new_idlist.append(test_id)
testgen.parametrize(metafunc, argnames, new_argvalues, ids=new_idlist, scope="module")
def pytest_generate_tests(metafunc):
# Filter out providers without provisioning data or hosts defined
argnames, argvalues, idlist = testgen.all_providers(metafunc)
new_idlist = []
new_argvalues = []
for i, argvalue_tuple in enumerate(argvalues):
args = dict(zip(argnames, argvalue_tuple))
if metafunc.function in {test_vm_genealogy_detected} \
and args["provider"].one_of(SCVMMProvider, RHEVMProvider):
continue
new_idlist.append(idlist[i])
new_argvalues.append(argvalues[i])
testgen.parametrize(metafunc,
argnames,
new_argvalues,
ids=new_idlist,
scope="module")
def pytest_generate_tests(metafunc):
argnames, argvalues, idlist = testgen.providers_by_class(
metafunc, [RHEVMProvider, VMwareProvider], required_fields=['datastores'])
argnames.append('datastore_type')
new_idlist = []
new_argvalues = []
for index, argvalue_tuple in enumerate(argvalues):
args = dict(zip(argnames, argvalue_tuple))
datastores = args['provider'].data.datastores
for ds in datastores:
if not ds.get('test_fleece', False):
continue
assert ds['type'] in DATASTORE_TYPES, (
'datastore type must be set to [{}] for smartstate analysis tests'.format(
'|'.join(DATASTORE_TYPES)))
new_argvalues.append([args["provider"], ds['type']])
test_id = '{}-{}'.format(idlist[index], ds['type'])
new_idlist.append(test_id)
testgen.parametrize(metafunc, argnames, new_argvalues, ids=new_idlist, scope="module")
def pytest_generate_tests(metafunc):
if metafunc.function in {test_rh_updates}:
return
""" Generates tests specific to RHSM or SAT6 with proxy-on or off """
argnames = ['reg_method', 'reg_data', 'proxy_url', 'proxy_creds']
argvalues = []
idlist = []
try:
holder = metafunc.config.pluginmanager.get_plugin('appliance-holder')
stream = holder.held_appliance.version.stream()
all_reg_data = conf.cfme_data.get('redhat_updates', {})['streams'][stream]
except KeyError:
logger.warning('Could not find rhsm data for stream in yaml')
pytest.mark.uncollect(
metafunc.function, message='Could not find rhsm data for stream in yaml')
return
if 'reg_method' in metafunc.fixturenames:
for reg_method in REG_METHODS:
reg_data = all_reg_data.get(reg_method)
if not reg_data or not reg_data.get('test_registration', False):
continue
proxy_data = conf.cfme_data.get('redhat_updates', {}).get('http_proxy', False)
if proxy_data and reg_data.get('use_http_proxy', False):
proxy_url = proxy_data['url']
proxy_creds_key = proxy_data['credentials']
proxy_creds = conf.credentials[proxy_creds_key]
argval = [reg_method, reg_data, proxy_url, proxy_creds]
argid = '{}-{}'.format(reg_method, 'proxy_on')
idlist.append(argid)
argvalues.append(argval)
argval = [reg_method, reg_data, None, None]
argid = '{}-{}'.format(reg_method, 'proxy_off')
idlist.append(argid)
argvalues.append(argval)
parametrize(metafunc, argnames, argvalues, ids=idlist, scope="module")
def pytest_generate_tests(metafunc):
argnames, argvalues, idlist = testgen.providers_by_class(
metafunc, [CloudProvider, InfraProvider], required_fields=['vm_analysis_new'])
argnames.append('analysis_type')
new_idlist = []
new_argvalues = []
for index, argvalue_tuple in enumerate(argvalues):
args = dict(zip(argnames, argvalue_tuple))
vma_data = args['provider'].data.vm_analysis_new
if 'vms' in vma_data:
vms = vma_data.vms
for vm_analysis_key in vms:
# Set VM name here
new_idlist.append('{}-{}'.format(idlist[index], vm_analysis_key))
new_argvalues.append([args["provider"], vm_analysis_key])
else:
# TODO FIXME
logger.error("Provider %s does not have the correct keys in the yaml",
args['provider'].name)
continue
testgen.parametrize(metafunc, argnames, new_argvalues, ids=new_idlist, scope="module")
def process_env_mark(self, metafunc):
if hasattr(metafunc.function, self.NAME):
if getattr(metafunc.function, self.NAME).args:
mark_param = getattr(metafunc.function, self.NAME).args[0]
else:
raise Exception('No keyword given to mark')
if mark_param == testgen.ALL:
metafunc.fixturenames.append(self.NAME)
testgen.parametrize(metafunc, self.NAME, self.CHOICES)
elif mark_param == testgen.ONE:
metafunc.fixturenames.append(self.NAME)
testgen.parametrize(metafunc, self.NAME, [self.CHOICES[0]])
elif mark_param == testgen.NONE:
return
elif self.PARAM_BY_DEFAULT:
metafunc.fixturenames.append(self.NAME)
testgen.parametrize(metafunc, self.NAME, [self.CHOICES[0]])
else:
return
def pytest_generate_tests(metafunc):
# Filter out providers without provisioning data or hosts defined
argnames, argvalues, idlist = testgen.all_providers(metafunc)
testgen.parametrize(metafunc, argnames, argvalues, ids=idlist, scope="module")
