def test_keypair_crud_with_key(openstack_provider):
""" This will test whether it will create new Keypair and then deletes it.
Steps:
* Provide Keypair name.
* Select Cloud Provider.
* Also delete it.
"""
key = RSA.generate(1024)
public_key = key.publickey().exportKey('OpenSSH')
keypair = KeyPair(name=fauxfactory.gen_alphanumeric(),
public_key=public_key,
provider=openstack_provider)
try:
keypair.create()
except TimedOutError:
if BZ(1444520, forced_streams=['5.6', '5.7', 'upstream']).blocks:
pytest.skip('Timed out creating keypair, BZ1444520')
else:
pytest.fail('Timed out creating keypair')
assert keypair.exists
try:
keypair.delete(wait=True)
except TimedOutError:
openstack_provider.mgmt.api.keypairs.delete(keypair.name)
pytest.fail('Timed out deleting keypair')
with pytest.raises(KeyPairNotFound):
navigate_to(keypair, 'Details')
def test_edit_requests(self, collection, rest_api, requests_pending,
from_detail):
"""Tests editing requests using /api/requests.
Metadata:
test_flag: rest, requests
"""
body = {'options': {'arbitrary_key_allowed': 'test_rest'}}
if from_detail:
if BZ('1418331', forced_streams=['5.7', 'upstream']).blocks:
pytest.skip("Affected by BZ1418331, cannot test.")
for request in requests_pending:
request.action.edit(**body)
assert rest_api.response.status_code == 200
else:
identifiers = []
for i, resource in enumerate(requests_pending):
loc = ({
'id': resource.id
}, {
'href': '{}/{}'.format(collection._href, resource.id)
})
identifiers.append(loc[i % 2])
collection.action.edit(*identifiers, **body)
assert rest_api.response.status_code == 200
for request in requests_pending:
request.reload()
assert request.options['arbitrary_key_allowed'] == 'test_rest'
def test_vm_retire_extend(request, testing_vm, soft_assert,
retire_extend_button):
""" Tests extending a retirement using an AE method.
Prerequisities:
* A running VM on any provider.
Steps:
* It creates a button pointing to ``Request/vm_retire_extend`` instance. The button should
live in the VM and Instance button group.
* Then it sets a retirement date for the VM
* Then it waits until the retirement date is set
* Then it clicks the button that was created and it waits for the retirement date to extend.
Metadata:
test_flag: retire, provision
"""
num_days = 5
soft_assert(testing_vm.retirement_date == 'Never',
"The retirement date is not 'Never'!")
retirement_date = generate_retirement_date(delta=num_days)
testing_vm.set_retirement_date(retirement_date)
wait_for(lambda: testing_vm.retirement_date != 'Never',
message="retirement date set")
set_date = testing_vm.retirement_date
if not BZ(1419150, forced_streams='5.6').blocks:
soft_assert(
set_date == retirement_date.strftime(pick(VM.RETIRE_DATE_FMT)),
"The retirement date '{}' did not match expected date '{}'".format(
set_date, retirement_date.strftime(pick(VM.RETIRE_DATE_FMT))))
# current_retirement_date = testing_vm.retirement_date
# Now run the extend stuff
retire_extend_button()
def test_keypair_add_and_remove_tag(openstack_provider, keypairs):
""" This will test whether it will add and remove tag for newly created Keypair or not
and then deletes it.
Steps:
* Provide Keypair name.
* Select Cloud Provider.
* Add tag to Keypair.
* Remove tag from Keypair
* Also delete it.
"""
tag = ('Department', 'Accounting')
try:
keypair = keypairs.create(fauxfactory.gen_alphanumeric(), openstack_provider)
except TimedOutError:
if BZ(1444520, forced_streams=['5.6', '5.7', 'upstream']).blocks:
pytest.skip('Timed out creating keypair, BZ1444520')
else:
pytest.fail('Timed out creating keypair')
assert keypair.exists
keypair.add_tag(tag)
tagged_value = mixins.get_tags(tag="My Company Tags")
assert tuple(tagged_value[0].split(": ", 1)) == tag, "Add tag failed."
keypair.remove_tag(tag)
tagged_value1 = mixins.get_tags(tag="My Company Tags")
assert tagged_value1 != tagged_value, "Remove tag failed."
# Above small conversion in assert statement convert 'tagged_value' in tuple("a","b") and then
# compare with tag which is tuple. As get_tags will return assigned tag in list format["a: b"].
keypair.delete(wait=True)
assert not keypair.exists
def pytest_runtest_protocol(item):
global session_ver
global session_build
global session_stream
if not session_ver:
session_ver = str(version.current_version())
session_build = store.current_appliance.build
session_stream = store.current_appliance.version.stream()
fire_art_hook(item.config,
'session_info',
version=session_ver,
build=session_build,
stream=session_stream)
tier = item.get_marker('tier')
if tier:
tier = tier.args[0]
requirement = item.get_marker('requirement')
if requirement:
requirement = requirement.args[0]
try:
params = item.callspec.params
param_dict = {p: get_name(v) for p, v in params.iteritems()}
except:
param_dict = {}
ip = urlparse(env['base_url']).netloc
# This pre_start_test hook is needed so that filedump is able to make get the test
# object set up before the logger starts logging. As the logger fires a nested hook
# to the filedumper, and we can't specify order inriggerlib.
meta = item.get_marker('meta')
if meta and 'blockers' in meta.kwargs:
blocker_spec = meta.kwargs['blockers']
blockers = []
for blocker in blocker_spec:
if isinstance(blocker, int):
blockers.append(BZ(blocker).url)
else:
blockers.append(Blocker.parse(blocker).url)
else:
blockers = []
fire_art_test_hook(item, 'pre_start_test', slaveid=store.slaveid, ip=ip)
fire_art_test_hook(item,
'start_test',
slaveid=store.slaveid,
ip=ip,
tier=tier,
requirement=requirement,
param_dict=param_dict,
issues=blockers)
yield
def create(self):
sel.force_navigate('timeprofile_new')
fill(self.timeprofile_form, {
'description': self.description,
'scope': self.scope,
'days': self.days,
'hours': self.hours,
'timezone': self.timezone,
},
action=self.save_button)
tp_ui_bug = BZ(1334440, forced_streams=["5.6"])
if not tp_ui_bug.blocks:
flash.assert_success_message('Time Profile "{}" was added'.format(
self.description))
def test_unset_retirement_date(retire_vm):
"""Tests cancelling a scheduled retirement by removing the set date
"""
num_days = 3
retire_date = generate_retirement_date(delta=num_days)
retire_vm.set_retirement_date(retire_date)
if BZ(1419150, forced_streams=['5.6']).blocks:
# The date is wrong, but we can still test unset
logger.warning('Skipping test step verification for BZ 1419150')
else:
verify_retirement_date(retire_vm, expected_date=retire_date)
retire_vm.set_retirement_date(None)
verify_retirement_date(retire_vm, expected_date='Never')
def test_order_multiple_catalog_items(self, request, appliance,
service_catalogs, service_templates):
"""Tests ordering multiple catalog items using the REST API.
Metadata:
test_flag: rest
"""
catalog = service_catalogs[0]
unassign_templates(service_templates)
for template in service_templates:
catalog.service_templates.action.assign(template)
template.reload()
# this doesn't return resource in the "service_requests" collection
# using workarount with `response.json()`
catalog.service_templates.action.order(*service_templates)
results = appliance.rest_api.response.json()
results = results['results']
assert_response(appliance)
if not BZ(1480281, forced_streams=['5.7', '5.8', 'upstream']).blocks:
assert 'href' in results[0], "BZ 1480281 doesn't seem to be fixed"
def _order_finished(service_request):
service_request.reload()
return (service_request.status.lower() == 'ok'
and service_request.request_state.lower() == 'finished')
new_services = []
for index, result in enumerate(results):
service_request = appliance.rest_api.get_entity(
'service_requests', result['id'])
wait_for(_order_finished,
func_args=[service_request],
num_sec=180,
delay=10)
service_name = re.search(
r'\[({}[0-9-]*)\] '.format(service_templates[index].name),
service_request.message).group(1)
# this fails if the service with the `service_name` doesn't exist
new_service = appliance.rest_api.collections.services.get(
name=service_name)
new_services.append(new_service)
@request.addfinalizer
def _finished():
appliance.rest_api.collections.services.action.delete(
*new_services)
class TestProvisioning(object):
WAIT_TIME = 300
WAIT_TIME_SLOW = 600
SLOW_PROVIDERS = {"rhevm", "scvmm"}
@pytest.mark.meta(
server_roles="+automate",
blockers=[
BZ(1118831,
unblock=lambda appliance_version: appliance_version < "5.3"),
1131480, 1132578
])
@pytest.mark.usefixtures("setup_provider_clsscope")
def test_provision_via_soap(self, request, soap_client, provider_key,
provider_data, provider_mgmt, small_template,
provider_type):
"""Tests soap
Metadata:
test_flag: soap, provision
"""
# rhev-m and scvmm need extra time to make their minds
wtime = self.WAIT_TIME if provider_type not in self.SLOW_PROVIDERS else self.WAIT_TIME_SLOW
vm_name = "test_soap_provision_{}".format(
fauxfactory.gen_alphanumeric())
vlan = provider_data.get("provisioning", {}).get("vlan", None)
def _cleanup():
try:
if provider_mgmt.does_vm_exist(vm_name):
provider_mgmt.delete_vm(vm_name)
except:
pass
request.addfinalizer(_cleanup)
set_client(soap_client)
vm = MiqVM.provision_from_template(
small_template,
vm_name,
vlan=vlan,
wait_min=10,
)
request.addfinalizer(lambda: vm.delete() if vm.exists else None)
if vm.is_powered_on:
vm.power_off()
vm.wait_powered_off(wait_time=wtime)
vm.power_on()
vm.wait_powered_on(wait_time=wtime)
def test_keypair_crud(openstack_provider, keypairs):
""" This will test whether it will create new Keypair and then deletes it.
Steps:
* Provide Keypair name.
* Select Cloud Provider.
* Also delete it.
"""
try:
keypair = keypairs.create(name=fauxfactory.gen_alphanumeric(), provider=openstack_provider)
except TimedOutError:
if BZ(1444520, forced_streams=['5.6', '5.7', 'upstream']).blocks:
pytest.skip('Timed out creating keypair, BZ1444520')
else:
pytest.fail('Timed out creating keypair')
assert keypair.exists
keypair.delete(wait=True)
assert not keypair.exists
def test_delete_notifications_from_detail(self, rest_api, generate_notifications, method):
"""Tests delete notifications from detail.
Metadata:
test_flag: rest
"""
if method == 'delete' and BZ('1420872', forced_streams=['5.7', 'upstream']).blocks:
pytest.skip("Affected by BZ1420872, cannot test.")
collection = rest_api.collections.notifications
collection.reload()
notifications = [collection[-i] for i in range(1, 3)]
status = 204 if method == 'delete' else 200
for entity in notifications:
entity.action.delete(force_method=method)
assert rest_api.response.status_code == status
with error.expected('ActiveRecord::RecordNotFound'):
entity.action.delete(force_method=method)
assert rest_api.response.status_code == 404
def test_keypair_crud_with_key(openstack_provider, keypairs):
""" This will test whether it will create new Keypair and then deletes it.
Steps:
* Provide Keypair name.
* Select Cloud Provider.
* Also delete it.
"""
key = RSA.generate(1024)
public_key = key.publickey().exportKey('OpenSSH')
try:
keypair = keypairs.create(fauxfactory.gen_alphanumeric(), openstack_provider, public_key)
except TimedOutError:
if BZ(1444520, forced_streams=['5.6', '5.7', 'upstream']).blocks:
pytest.skip('Timed out creating keypair, BZ1444520')
else:
pytest.fail('Timed out creating keypair')
assert keypair.exists
keypair.delete(wait=True)
assert not keypair.exists
def test_keypair_crud(openstack_provider):
""" This will test whether it will create new Keypair and then deletes it.
Steps:
* Provide Keypair name.
* Select Cloud Provider.
* Also delete it.
"""
keypair = KeyPair(name=fauxfactory.gen_alphanumeric(),
provider=openstack_provider)
try:
keypair.create()
except TimedOutError:
if BZ(1444520, forced_streams=['5.6', '5.7', 'upstream']).blocks:
pytest.skip('Timed out creating keypair, BZ1444520')
else:
pytest.fail('Timed out creating keypair')
view = navigate_to(keypair, 'Details')
assert view.is_displayed
keypair.delete(wait=True)
with pytest.raises(KeyPairNotFound):
navigate_to(keypair, 'Details')
def test_resume_retired_instance(retire_vm, provider, remove_date):
"""Test resuming a retired instance, should be supported for infra and cloud, though the
actual recovery results may differ depending on state after retirement
Two methods to resume:
1. Set a retirement date in the future
2. Remove the set retirement date
"""
num_days = 5
retire_vm.retire()
verify_retirement_state(retire_vm)
retire_date = None if remove_date else generate_retirement_date(
delta=num_days)
retire_vm.set_retirement_date(retire_date)
if BZ(1419150, forced_streams=['5.6']).blocks and not remove_date:
# The date is wrong in 5.6, but we can still test unset
logger.warning('Skipping test step verification for BZ 1419150')
else:
verify_retirement_date(
retire_vm, expected_date=retire_date if retire_date else 'Never')
assert retire_vm.is_retired is False
provision_request.message))
return provision_request.request_state.lower() in {
"finished", "provisioned"
}
wait_for(_finished,
num_sec=600,
delay=5,
message="REST provisioning finishes")
assert provider.mgmt.does_vm_exist(
vm_name), "The VM {} does not exist!".format(vm_name)
@pytest.mark.tier(2)
@pytest.mark.meta(
blockers=[BZ(1437689, forced_streams=['5.6', '5.7', '5.8', 'upstream'])])
@pytest.mark.meta(server_roles="+automate")
@pytest.mark.usefixtures("setup_provider")
def test_create_pending_provision_requests(rest_api, provider, small_template):
"""Tests creation of pending provision request using /api/provision_requests.
Metadata:
test_flag: rest, provision
"""
provision_data = get_provision_data(rest_api,
provider,
small_template,
auto_approve=False)
response = rest_api.collections.provision_requests.action.create(
**provision_data)
assert rest_api.response.status_code == 200
context={'folder_name': 'Global Filters'})
assert sel.is_displayed_text(df.name), "Default Filter settings Failed!"
def test_infrastructuretemplates_defaultfilters(setup_first_provider):
filters = [[
'Infrastructure', 'Virtual Machines', 'Templates', 'Platform / Redhat'
]]
df = st.DefaultFilter(name='Platform / Redhat')
df.update({'filters': [(k, True) for k in filters]})
sel.force_navigate('infra_templates_filter_folder',
context={'folder_name': 'Global Filters'})
assert sel.is_displayed_text(df.name), "Default Filter settings Failed!"
@pytest.mark.meta(blockers=[BZ(1290300, forced_streams=["upstream"])])
def test_servicetemplateandimages_defaultfilters(setup_first_provider):
filters = [[
'Services', 'Workloads', 'Templates & Images', 'Platform / Microsoft'
]]
df = st.DefaultFilter(name='Platform / Microsoft')
df.update({'filters': [(k, True) for k in filters]})
sel.force_navigate('service_templates_images_filter_folder',
context={'folder_name': 'Global Filters'})
assert sel.is_displayed_text(df.name), "Default Filter settings Failed!"
def test_servicevmsandinstances_defaultfilters(setup_first_provider):
filters = [[
'Services', 'Workloads', 'VMs & Instances', 'Platform / Openstack'
]]
widget.minimize()
assert widget.is_minimized
widget.restore()
assert not widget.is_minimized
if widget.can_zoom:
widget.zoom()
assert Widget.is_zoomed()
assert widget.name == Widget.get_zoomed_name()
Widget.close_zoom()
assert not Widget.is_zoomed()
widget.footer
widget.content
@pytest.mark.meta(blockers=[
BZ(1110171, unblock=lambda number_dashboards: number_dashboards != 1)
])
@pytest.mark.parametrize("number_dashboards", range(1, 4))
def test_custom_dashboards(request, soft_assert, number_dashboards):
"""Create some custom dashboards and check their presence. Then check their contents."""
# Very useful construct. List is mutable, so we can prepare the generic delete finalizer.
# Then we add everything that succeeded with creation. Simple as that :)
dashboards = []
request.addfinalizer(lambda: map(lambda item: item.delete(), dashboards))
def _create_dashboard(widgets):
return Dashboard(fauxfactory.gen_alphanumeric(),
"EvmGroup-super_administrator",
fauxfactory.gen_alphanumeric(),
locked=False,
widgets=widgets)
from cfme.common.vm import VM
from cfme.common.provider import BaseProvider
from cfme.configure.configuration import get_server_roles, set_server_roles, candu
from cfme.infrastructure.provider.rhevm import RHEVMProvider
from cfme.infrastructure.provider.virtualcenter import VMwareProvider
from cfme.intelligence.reports.reports import CustomReport
from fixtures.provider import setup_or_skip
from utils import testgen
from utils.blockers import BZ
from utils.log import logger
from utils.wait import wait_for
pytestmark = [
pytest.mark.tier(2),
pytest.mark.meta(blockers=[
BZ(1433984, forced_streams=["5.7", "5.8", "upstream"]),
BZ(1465387, forced_streams=["5.8"])
]), test_requirements.chargeback
]
def pytest_generate_tests(metafunc):
# Filter out providers not meant for Chargeback Testing
argnames, argvalues, idlist = testgen.providers_by_class(
metafunc, [VMwareProvider, RHEVMProvider],
required_fields=[(['cap_and_util', 'test_chargeback'], True)])
new_argvalues = []
new_idlist = []
for i, argvalue_tuple in enumerate(argvalues):
class TestPoliciesRESTAPI(object):
@pytest.fixture(scope='function')
def policies(self, request, appliance):
num_policies = 2
response = _policies(request, appliance.rest_api, num=num_policies)
assert appliance.rest_api.response.status_code == 200
assert len(response) == num_policies
return response
@pytest.mark.uncollectif(lambda: current_version() < '5.8')
def test_create_policies(self, appliance, policies):
"""Tests create policies.
Metadata:
test_flag: rest
"""
for policy in policies:
record = appliance.rest_api.collections.policies.get(id=policy.id)
assert record.description == policy.description
@pytest.mark.uncollectif(lambda: current_version() < '5.8')
def test_delete_policies_from_detail_post(self, policies, appliance):
"""Tests delete policies from detail using POST method.
Metadata:
test_flag: rest
"""
for policy in policies:
policy.action.delete(force_method='post')
assert appliance.rest_api.response.status_code == 200
with error.expected('ActiveRecord::RecordNotFound'):
policy.action.delete(force_method='post')
assert appliance.rest_api.response.status_code == 404
@pytest.mark.uncollectif(lambda: current_version() < '5.8')
@pytest.mark.meta(
blockers=[BZ(1435773, forced_streams=['5.8', 'upstream'])])
def test_delete_policies_from_detail_delete(self, policies, appliance):
"""Tests delete policies from detail using DELETE method.
Metadata:
test_flag: rest
"""
for policy in policies:
policy.action.delete(force_method='delete')
assert appliance.rest_api.response.status_code == 204
with error.expected('ActiveRecord::RecordNotFound'):
policy.action.delete(force_method='delete')
assert appliance.rest_api.response.status_code == 404
@pytest.mark.uncollectif(lambda: current_version() < '5.8')
def test_delete_policies_from_collection(self, policies, appliance):
"""Tests delete policies from collection.
Metadata:
test_flag: rest
"""
collection = appliance.rest_api.collections.policies
collection.action.delete(*policies)
assert appliance.rest_api.response.status_code == 200
with error.expected('ActiveRecord::RecordNotFound'):
collection.action.delete(*policies)
assert appliance.rest_api.response.status_code == 404
@pytest.mark.uncollectif(lambda: current_version() < '5.8')
@pytest.mark.meta(
blockers=[BZ(1435777, forced_streams=['5.8', 'upstream'])])
@pytest.mark.parametrize('from_detail', [True, False],
ids=['from_detail', 'from_collection'])
def test_edit_policies(self, policies, appliance, from_detail):
"""Tests edit policies.
Metadata:
test_flag: rest
"""
num_policies = len(policies)
uniq = [fauxfactory.gen_alphanumeric(5) for _ in range(num_policies)]
new = [{
'description': 'Edited Test Policy {}'.format(u)
} for u in uniq]
if from_detail:
edited = []
for i in range(num_policies):
edited.append(policies[i].action.edit(**new[i]))
assert appliance.rest_api.response.status_code == 200
else:
for i in range(num_policies):
new[i].update(policies[i]._ref_repr())
edited = appliance.rest_api.collections.policies.action.edit(*new)
assert appliance.rest_api.response.status_code == 200
assert len(edited) == num_policies
for i in range(num_policies):
assert edited[i].description == new[i]['description']
* Assert that the widgets order is changed
"""
request.addfinalizer(dashboards.default.widgets.reset)
previous_state = dashboards.default.widgets.all()
previous_names = [w.name for w in previous_state]
first_widget = previous_state[0]
second_widget = previous_state[1]
dashboards.default.drag_and_drop(first_widget, second_widget)
new_state = dashboards.default.widgets.all()
new_names = [w.name for w in new_state]
assert previous_names[2:] == new_names[2:]
assert previous_names[0] == new_names[1]
assert previous_names[1] == new_names[0]
@pytest.mark.meta(blockers=[BZ(1316134, forced_streams=['5.7', '5.8', 'upstream'])])
def test_drag_and_drop_widget_to_the_bottom_of_another_column(dashboards, request):
"""In this test we try to drag and drop a left upper widget to
the bottom of the middle column.
Prerequisities:
* A list of widgets on the default dashboard
Steps:
* Go to the Dashboard
* Drag a left upper widget and drop it under the bottom widget of the near column
* Assert that the widgets order is changed
"""
request.addfinalizer(dashboards.default.widgets.reset)
first_column = dashboards.default.dashboard_view.column_widget_names(1)
second_column = dashboards.default.dashboard_view.column_widget_names(2)
item_name = fauxfactory.gen_alphanumeric()
catalog_item = CatalogItem(item_type="RHEV",
name=item_name,
description="my catalog",
display_in=True,
catalog=catalog,
dialog=dialog,
catalog_name=iso_template,
provider=provider.name,
prov_data=provisioning_data)
yield catalog_item
@pytest.mark.meta(
blockers=[BZ(1246686, forced_streams=["5.4", "5.5", "upstream"])])
@pytest.mark.usefixtures('setup_iso_datastore')
def test_rhev_iso_servicecatalog(setup_provider, provider, catalog_item,
request):
"""Tests RHEV ISO service catalog
Metadata:
test_flag: iso, provision
"""
vm_name = catalog_item.provisioning_data["vm_name"]
request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider))
catalog_item.create()
service_catalogs = ServiceCatalogs("service_name")
service_catalogs.order(catalog_item.catalog, catalog_item)
# nav to requests page happens on successful provision
logger.info('Waiting for cfme provision request for service %s',
pytest.mark.usefixtures("setup_provider")]
pytest_generate_tests = testgen.generate([ContainersProvider], scope='function')
DataSet = namedtuple('DataSet', ['match_page', 'start_page_name'])
data_sets = (
DataSet(match_page_containersoverview, 'Containers / Overview'),
DataSet(match_page_containersprovider, 'Containers / Providers'),
DataSet(match_page_node, 'Containers / Nodes'),
DataSet(match_page_pod, 'Containers / Pods'),
DataSet(match_page_service, 'Containers / Services'),
DataSet(match_page_container, 'Containers / Explorer')
)
@pytest.mark.meta(blockers=[BZ(1446265, forced_streams=["5.8", "upstream"])])
@pytest.mark.polarion('CMP-10601')
def test_start_page(appliance, soft_assert):
for data_set in data_sets:
settings.visual.login_page = data_set.start_page_name
login_page = navigate_to(appliance.server, 'LoginScreen')
login_page.login_admin()
soft_assert(
data_set.match_page(),
'Configured start page is "{}", but the start page now'
' is "{}" instead of "{}"'.format(
data_set.start_page_name, browser_title(),
data_set.match_page.keywords['title'],
)
)
def test_pxe_image_type_required_error_validation():
"""Test to validate pxe image type in customization templates."""
template_name = pxe.CustomizationTemplate(
name=fauxfactory.gen_alphanumeric(8),
description=fauxfactory.gen_alphanumeric(16),
image_type='<Choose>',
script_type='Kickstart',
script_data='Testing the script')
with error.expected("Pxe_image_type can't be blank"):
template_name.create()
@pytest.mark.meta(
blockers=[
BZ(1092951, ignore_bugs=[1083198])
]
)
def test_duplicate_name_error_validation():
"""Test to validate duplication in customization templates."""
template_name = pxe.CustomizationTemplate(
name=fauxfactory.gen_alphanumeric(8),
description=fauxfactory.gen_alphanumeric(16),
image_type='RHEL-6',
script_type='Kickstart',
script_data='Testing the script')
template_name.create()
with error.expected('Name has already been taken'):
template_name.create()
template_name.delete(cancel=False)
custom_report.delete()
@pytest.mark.tier(3)
@pytest.mark.meta(blockers=[1202412])
@test_requirements.report
def test_schedule_crud(schedule):
schedule.create()
with update(schedule):
schedule.description = "badger badger badger"
schedule.queue(wait_for_finish=True)
schedule.delete()
@pytest.mark.tier(3)
@pytest.mark.meta(blockers=[BZ(1388144, forced_streams=["5.7", "upstream"])])
def test_menuwidget_crud():
w = MenuWidget(
fauxfactory.gen_alphanumeric(),
description=fauxfactory.gen_alphanumeric(),
active=True,
shortcuts={
"Services / Catalogs": fauxfactory.gen_alphanumeric(),
"Clouds / Providers": fauxfactory.gen_alphanumeric(),
},
visibility=["<By Role>",
sel.ByText("EvmRole-administrator")])
w.create()
with update(w):
w.active = False
w.delete()
@pytest.mark.parametrize('visibility', [True, False], ids=['visible', 'notVisible'])
def test_tagvis_cloud_object(check_item_visibility, testing_vis_object, visibility):
""" Tests infra provider and its items honors tag visibility
Prerequisites:
Catalog, tag, role, group and restricted user should be created
Steps:
1. As admin add tag
2. Login as restricted user, item is visible for user
3. As admin remove tag
4. Login as restricted user, item is not visible for user
"""
check_item_visibility(testing_vis_object, visibility)
@pytest.mark.meta(blockers=[BZ(1441637)])
@pytest.mark.uncollectif(lambda: version.current_version() >= "5.7")
@pytest.mark.parametrize('visibility', [True, False], ids=['visible', 'notVisible'])
def test_tagvis_cloud_keypair(check_item_visibility, key_pair, visibility):
""" Tests infra provider and its items honors tag visibility
Prerequisites:
Catalog, tag, role, group and restricted user should be created
Additionally cloud key_pair should be created
Steps:
1. As admin add tag to key_pair
2. Login as restricted user, key_pair is visible for user
3. As admin remove tag from key_pair
4. Login as restricted user, key_pair is not visible for user
"""
check_item_visibility(key_pair, visibility)
catalog_item = CatalogItem(item_type=item_type,
name=item_name,
description="my catalog",
display_in=True,
catalog=catalog,
dialog=dialog,
provider=provider,
provider_type=provider_type,
config_template=template)
request.addfinalizer(catalog_item.delete)
return catalog_item
@pytest.mark.tier(2)
@pytest.mark.ignore_stream("upstream")
@pytest.mark.meta(blockers=[BZ(1437686, forced_streams=["5.8"])])
def test_order_catalog_item(catalog_item, request):
"""Tests order catalog item
Metadata:
test_flag: provision
"""
catalog_item.create()
service_catalogs = ServiceCatalogs(catalog_item.catalog, catalog_item.name)
service_catalogs.order()
logger.info('Waiting for cfme provision request for service %s',
catalog_item.name)
cells = {'Description': catalog_item.name}
row, __ = wait_for(requests.wait_for_request, [cells, True],
fail_func=requests.reload,
num_sec=1400,
delay=20)
from cfme.common.provider import cleanup_vm
from cfme.provisioning import do_vm_provisioning
from cfme.services import requests
from cfme.web_ui import fill
from utils import normalize_text, testgen
from utils.blockers import BZ
from utils.log import logger
from utils.mgmt_system import RHEVMSystem
from utils.wait import wait_for
pytestmark = [
pytest.mark.meta(server_roles="+automate +notifier"),
pytest.mark.usefixtures('uses_infra_providers'),
pytest.mark.meta(blockers=[
BZ(1265466,
unblock=lambda provider: not isinstance(provider.mgmt, RHEVMSystem))
]),
pytest.mark.tier(2)
]
def pytest_generate_tests(metafunc):
# Filter out providers without provisioning data or hosts defined
argnames, argvalues, idlist = testgen.infra_providers(
metafunc,
required_fields=[['provisioning',
'template'], ['provisioning', 'host'],
['provisioning', 'datastore']])
testgen.parametrize(metafunc,
argnames,
argvalues,
new_idlist.append(idlist[i])
new_argvalues.append(argvalues[i])
testgen.parametrize(metafunc,
argnames,
new_argvalues,
ids=new_idlist,
scope="module")
pytestmark = [
pytest.mark.long_running,
pytest.mark.meta(blockers=[
BZ(1149128,
unblock=lambda provider: not isinstance(provider.mgmt, mgmt_system.
SCVMMSystem))
])
]
def get_vm_object(vm_name):
"""Looks up the CFME database for the VM.
Args:
vm_name: VM name
Returns:
If found, :py:class:`utils.miq_soap.MiqVM` for 5.4 and :py:class:`utils.api.Entity` for 5.5
If not, `None`
"""
if current_version() < "5.5":
@pytest.fixture(scope="module")
def temp_appliance_extended_db(temp_appliance_preconfig):
app = temp_appliance_preconfig
app.stop_evm_service()
app.extend_db_partition()
app.start_evm_service()
return app
@pytest.mark.ignore_stream('5.5', 'upstream')
@pytest.mark.tier(2)
@pytest.mark.uncollectif(
lambda db_version: db_version >= version.current_version(
) or version.get_stream(db_version) == version.current_stream())
@pytest.mark.meta(
blockers=[BZ(1354466, unblock=lambda db_url: 'ldap' not in db_url)])
def test_db_migrate(app_creds, temp_appliance_extended_db, db_url, db_version,
db_desc):
app = temp_appliance_extended_db
# Download the database
logger.info("Downloading database: {}".format(db_desc))
url_basename = os_path.basename(db_url)
rc, out = app.ssh_client.run_command('curl -o "/tmp/{}" "{}"'.format(
url_basename, db_url),
timeout=30)
assert rc == 0, "Failed to download database: {}".format(out)
# The v2_key is potentially here
v2key_url = os_path.join(os_path.dirname(db_url), "v2_key")
except ValueError:
assert False, "Wrong file matching of {}".format(file.name)
datetimes.append((date_from, date_to, file.name))
# Check for the gaps
if len(datetimes) > 1:
for i in range(len(datetimes) - 1):
dt = datetimes[i + 1][0] - datetimes[i][1]
assert dt.total_seconds() >= 0.0, \
"Negative gap between log files ({}, {})".format(
datetimes[i][2], datetimes[i + 1][2])
@pytest.mark.tier(3)
@pytest.mark.nondestructive
@pytest.mark.meta(blockers=[BZ(1341502, unblock=lambda log_depot: log_depot.protocol != "anon_ftp",
forced_streams=["5.6", "5.7", "5.8", "upstream"])]
)
def test_collect_log_depot(log_depot, appliance, configured_depot, request):
""" Boilerplate test to verify functionality of this concept
Will be extended and improved.
"""
# Wipe the FTP contents in the end
@request.addfinalizer
def _clear_ftp():
with log_depot.ftp as ftp:
ftp.cwd(ftp.upload_dir)
ftp.recursively_delete()
# Prepare empty workspace
with log_depot.ftp as ftp:
