def a_provider(request):
pf = ProviderFilter(classes=[InfraProvider], required_fields=[
['provisioning', 'template'],
['provisioning', 'host'],
['provisioning', 'datastore'],
['provisioning', 'vlan'],
['provisioning', 'catalog_item_type']])
return setup_one_or_skip(request, filters=[pf])
def setup_one_or_skip(request, filters=None, use_global_filters=True):
""" Sets up one of matching providers or skips the test
Args:
filters: List of :py:class:`ProviderFilter` or None
request: Needed for logging a potential skip correctly in artifactor
use_global_filters: Will apply global filters as well if `True`, will not otherwise
"""
filters = filters or []
providers = list_providers(filters=filters, use_global_filters=use_global_filters)
# All providers filtered out?
if not providers:
global_providers = list_providers(filters=None, use_global_filters=use_global_filters)
if not global_providers:
# This can also mean that there simply are no providers in the yamls!
pytest.skip("No provider matching global filters found")
else:
pytest.skip("No provider matching test-specific filters found")
# Are all providers marked as problematic?
if _problematic_providers.issuperset(providers):
skip_msg = "All providers marked as problematic: {}".format([p.key for p in providers])
_artifactor_skip_providers(request, providers, skip_msg)
# If there is a provider already set up matching the user's requirements, reuse it
for provider in providers:
if provider.exists:
return provider
# If we have more than one provider, we create two separate groups of providers, preferred
# and not preferred, that we shuffle separately and then join together
if len(providers) > 1:
only_preferred_filter = ProviderFilter(required_fields=[("do_not_prefer", True)],
inverted=True)
preferred_providers = list_providers(
filters=filters + [only_preferred_filter], use_global_filters=use_global_filters)
not_preferred_providers = [p for p in providers if p not in preferred_providers]
random.shuffle(preferred_providers)
random.shuffle(not_preferred_providers)
providers = preferred_providers + not_preferred_providers
# Try to set up one of matching providers
non_existing = [prov for prov in providers if not prov.exists]
for provider in non_existing:
if _setup_provider_verbose(request, provider):
return provider
skip_msg = "Failed to set up any matching providers: {}", [p.key for p in providers]
_artifactor_skip_providers(request, non_existing, skip_msg)
def pytest_configure(config):
""" Filters the list of providers as part of pytest configuration
Note:
Additional filter is added to the global_filters dict of active filters here.
"""
cmd_filter = config.getvalueorskip('use_provider')
if not cmd_filter:
cmd_filter = ["default"]
new_filter = ProviderFilter(keys=cmd_filter, required_tags=cmd_filter, conjunctive=False)
global_filters['use_provider'] = new_filter
logger.debug('Filtering providers with {}, leaves {}'.format(
cmd_filter, [prov.key for prov in list_providers()]))
def providers_by_class(metafunc, classes, required_fields=None):
""" Gets providers by their class
Args:
metafunc: Passed in by pytest
classes: List of classes to fetch
required_fields: See :py:class:`cfme.utils.provider.ProviderFilter`
Usage:
# In the function itself
def pytest_generate_tests(metafunc):
argnames, argvalues, idlist = testgen.providers_by_class(
[GCEProvider, AzureProvider], required_fields=['provisioning']
)
metafunc.parametrize(argnames, argvalues, ids=idlist, scope='module')
# Using the parametrize wrapper
pytest_generate_tests = testgen.parametrize([GCEProvider], scope='module')
"""
pf = ProviderFilter(classes=classes, required_fields=required_fields)
return providers(metafunc, filters=[pf])
def providers(metafunc, filters=None):
""" Gets providers based on given (+ global) filters
Note:
Using the default 'function' scope, each test will be run individually for each provider
before moving on to the next test. To group all tests related to single provider together,
parametrize tests in the 'module' scope.
Note:
testgen for providers now requires the usage of test_flags for collection to work.
Please visit http://cfme-tests.readthedocs.org/guides/documenting.html#documenting-tests
for more details.
"""
filters = filters or []
argnames = []
argvalues = []
idlist = []
# Obtains the test's flags in form of a ProviderFilter
meta = getattr(metafunc.function, 'meta', None)
test_flag_str = getattr(meta, 'kwargs', {}).get('from_docs',
{}).get('test_flag')
if test_flag_str:
test_flags = test_flag_str.split(',')
flags_filter = ProviderFilter(required_flags=test_flags)
filters = filters + [flags_filter]
for provider in list_providers(filters):
argvalues.append([provider])
# Use the provider key for idlist, helps with readable parametrized test output
idlist.append(provider.key)
# Add provider to argnames if missing
if 'provider' in metafunc.fixturenames and 'provider' not in argnames:
metafunc.function = pytest.mark.uses_testgen()(metafunc.function)
argnames.append('provider')
if metafunc.config.getoption('sauce'):
break
return argnames, argvalues, idlist
def a_provider(request):
pf = ProviderFilter(classes=[InfraProvider], required_fields=['large'])
setup_one_or_skip(request, filters=[pf])
from cfme.infrastructure.provider.scvmm import SCVMMProvider
from cfme.rest.gen_data import a_provider as _a_provider
from cfme.rest.gen_data import vm as _vm
from cfme.web_ui import InfoBlock
from utils import version, testgen
from utils.appliance.implementations.ui import navigate_to
from utils.generators import random_vm_name
from utils.log import logger
from utils.providers import ProviderFilter
from utils.wait import wait_for
pytestmark = [
pytest.mark.tier(2),
pytest.mark.usefixtures("setup_provider_modscope")
]
not_scvmm = ProviderFilter(classes=[SCVMMProvider],
inverted=True) # scvmm doesn't provide events
all_prov = ProviderFilter(classes=[InfraProvider])
pytest_generate_tests = testgen.generate(gen_func=testgen.providers,
filters=[not_scvmm, all_prov],
scope='module')
@pytest.fixture(scope="module")
def new_vm(request, provider):
vm = VM.factory(random_vm_name("timelines", max_length=16), provider)
request.addfinalizer(vm.delete_from_provider)
if not provider.mgmt.does_vm_exist(vm.name):
logger.info("deploying %s on provider %s", vm.name, provider.key)
vm.create_on_provider(allow_skip="default", find_in_cfme=True)
def a_provider(request):
pf = ProviderFilter(classes=[VMwareProvider, RHEVMProvider])
return setup_one_or_skip(request, filters=[pf])
def providers(metafunc, filters=None, selector=ALL):
""" Gets providers based on given (+ global) filters
Note:
Using the default 'function' scope, each test will be run individually for each provider
before moving on to the next test. To group all tests related to single provider together,
parametrize tests in the 'module' scope.
Note:
testgen for providers now requires the usage of test_flags for collection to work.
Please visit http://cfme-tests.readthedocs.org/guides/documenting.html#documenting-tests
for more details.
"""
filters = filters or []
argnames = []
argvalues = []
idlist = []
# Obtains the test's flags in form of a ProviderFilter
meta = getattr(metafunc.function, 'meta', None)
test_flag_str = getattr(meta, 'kwargs', {}).get('from_docs', {}).get('test_flag')
if test_flag_str:
test_flags = test_flag_str.split(',')
flags_filter = ProviderFilter(required_flags=test_flags)
filters = filters + [flags_filter]
potential_providers = list_providers(filters)
if selector == ONE:
allowed_providers = [potential_providers[0]]
elif selector == LATEST:
allowed_providers = [sorted(
potential_providers, key=lambda k:LooseVersion(
str(k.data.get('version', 0))), reverse=True
)[0]]
elif selector == ONE_PER_TYPE:
types = set()
def add_prov(prov):
types.add(prov.type)
return prov
allowed_providers = [
add_prov(prov) for prov in potential_providers if prov.type not in types
]
elif selector == ONE_PER_CATEGORY:
categories = set()
def add_prov(prov):
categories.add(prov.category)
return prov
allowed_providers = [
add_prov(prov) for prov in potential_providers if prov.category not in categories
]
elif selector == ONE_PER_VERSION:
versions = set()
def add_prov(prov):
versions.add(prov.data.get('version', 0))
return prov
allowed_providers = [
add_prov(prov) for prov in potential_providers if prov.data.get(
'version', 0) not in versions
]
else:
allowed_providers = potential_providers
for provider in allowed_providers:
argvalues.append([provider])
# Use the provider key for idlist, helps with readable parametrized test output
idlist.append(provider.key)
# Add provider to argnames if missing
if 'provider' in metafunc.fixturenames and 'provider' not in argnames:
metafunc.function = pytest.mark.uses_testgen()(metafunc.function)
argnames.append('provider')
if metafunc.config.getoption('sauce') or selector == ONE:
break
return argnames, argvalues, idlist
def a_provider(request):
prov_filter = ProviderFilter(classes=[VMwareProvider])
return setup_one_or_skip(request, filters=[prov_filter])
from cfme.common.vm import VM
from cfme.infrastructure.provider import InfraProvider
from cfme.web_ui import toolbar as tb
from utils import testgen
from utils.blockers import BZ
from utils.generators import random_vm_name
from utils.log import logger
from utils.providers import ProviderFilter
from utils.timeutil import parsetime
from utils.wait import wait_for
from utils.version import pick, current_version
pytest_generate_tests = testgen.generate(
gen_func=testgen.providers,
filters=[
ProviderFilter(classes=[CloudInfraProvider],
required_flags=['provision', 'retire'])
])
pytestmark = [
pytest.mark.usefixtures('setup_provider'),
pytest.mark.tier(2), pytest.mark.long_running
]
RetirementWarning = namedtuple('RetirementWarning', ['id', 'string'])
warnings = [
RetirementWarning('no_warning', 'None'),
RetirementWarning('1_week_warning', '1 Week before retirement'),
RetirementWarning('2_week_warning', '2 Weeks before retirement'),
RetirementWarning('30_day_warning', '30 Days before retirement')
]
from cfme.common.vm import VM
from cfme.configure.configuration import VMwareConsoleSupport
from cfme.infrastructure.provider import InfraProvider
from utils import testgen, version, ssh
from utils.appliance.implementations.ui import navigate_to
from utils.conf import credentials
from utils.log import logger
from utils.providers import ProviderFilter
from wait_for import wait_for
pytestmark = pytest.mark.usefixtures('setup_provider')
pytest_generate_tests = testgen.generate(
gen_func=testgen.providers,
filters=[
ProviderFilter(classes=[InfraProvider],
required_flags=['webmks_console'])
],
scope='module')
@pytest.yield_fixture(scope="function")
def vm_obj(request, provider, setup_provider, console_template, vm_name):
"""VM creation/deletion fixture.
Create a VM on the provider with the given template, and return the vm_obj.
Also, remove VM from provider using nested function _delete_vm
after the test is completed.
"""
vm_obj = VM.factory(vm_name, provider, template_name=console_template)
vm_obj.create_on_provider(timeout=2400,
find_in_cfme=True,
def setup_perf_provider(request, use_global_filters=True):
pf = ProviderFilter(required_tags=['perf'])
return setup_one_or_skip(request,
filters=[pf],
use_global_filters=use_global_filters)
from cfme.configure.configuration import VMwareConsoleSupport
from cfme.infrastructure.provider.virtualcenter import VMwareProvider
from cfme.configure import configuration
from cfme.common.vm import VM
from utils import testgen, version, ssh
from utils.appliance.implementations.ui import navigate_to
from utils.log import logger
from utils.conf import credentials
from utils.providers import ProviderFilter
from wait_for import wait_for
pytestmark = pytest.mark.usefixtures('setup_provider')
pytest_generate_tests = testgen.generate(
gen_func=testgen.providers,
filters=[ProviderFilter(classes=[CloudInfraProvider], required_flags=['html5_console'])],
scope='module'
)
@pytest.fixture(scope="function")
def vm_obj(request, provider, setup_provider, console_template, vm_name):
"""
Create a VM on the provider with the given template, and return the vm_obj.
Also, it will remove VM from provider using nested function _delete_vm
after the test is completed.
"""
vm_obj = VM.factory(vm_name, provider, template_name=console_template)
def a_provider(request):
prov_filter = ProviderFilter(classes=[InfraProvider],
required_fields=['datacenters', 'clusters'])
return setup_one_or_skip(request, filters=[prov_filter])
def setup_one_by_class_or_skip(request, prov_class, use_global_filters=True):
pf = ProviderFilter(classes=[prov_class])
return setup_one_or_skip(request,
filters=[pf],
use_global_filters=use_global_filters)
def a_provider(request):
prov_filter = ProviderFilter(classes=[CloudProvider],
required_fields=[['provisioning', 'stack']])
return setup_one_or_skip(request, filters=[prov_filter])
from utils.log import logger
from utils.net import net_check
from utils.providers import ProviderFilter
from utils.ssh import SSHClient
from utils.update import update
from utils.wait import wait_for
pytestmark = [
pytest.mark.long_running,
pytest.mark.meta(server_roles=["+automate", "+notifier"]),
pytest.mark.tier(3), test_requirements.alert
]
CANDU_PROVIDER_TYPES = [VMwareProvider] # TODO: rhevm
pf1 = ProviderFilter(classes=[InfraProvider])
pf2 = ProviderFilter(classes=[SCVMMProvider], inverted=True)
pytest_generate_tests = testgen.generate(gen_func=testgen.providers,
filters=[pf1, pf2],
scope="module")
def wait_for_alert(smtp, alert, delay=None, additional_checks=None):
"""DRY waiting function
Args:
smtp: smtp_test funcarg
alert: Alert name
delay: Optional delay to pass to wait_for
additional_checks: Additional checks to perform on the mails. Keys are names of the mail
sections, values the values to look for.
