def test_generic_object_on_service_breadcrumb(appliance, generic_object):
"""
Bugzilla:
1741050
Polarion:
assignee: tpapaioa
initialEstimate: 1/6h
casecomponent: GenericObjects
testSteps:
1. Generate a service viewable under My Services
2. Create Generic Object Class & Instance
3. Assign the generic object instance to the service
4. Navigate to the service
5. Click on the generic object instances
6. Check the breadcrumb link
expectedResults:
1.
2.
3.
4.
5.
6. Breadcrumb should work properly
"""
# add generic object to service
myservice = MyService(appliance, name=generic_object.associations.get("services")[0].name)
with appliance.context.use(ViaREST):
myservice.add_resource_generic_object(generic_object)
# now navigate to the details of the generic_object
with appliance.context.use(ViaUI):
view = navigate_to(generic_object, "MyServiceDetails")
view.breadcrumb.click_location(myservice.name)
assert not view.is_displayed
view = myservice.create_view(MyServicesView)
assert view.is_displayed
def ansible_service(appliance, ansible_catalog_item):
service = MyService(appliance, ansible_catalog_item.name)
yield service
bulk_service_teardown(appliance) # deletes any service requests
if service.exists:
service.delete()
def test_retire_ansible_service_bundle(request, appliance, ansible_catalog_item, catalog,
ansible_tower_dialog):
"""
Polarion:
assignee: nansari
casecomponent: Services
testtype: functional
initialEstimate: 1/4h
startsin: 5.5
tags: service
Bugzilla:
1363897
"""
bundle_name = fauxfactory.gen_alphanumeric(start="bundle_")
catalog_bundle = appliance.collections.catalog_bundles.create(
bundle_name,
description="catalog_bundle",
display_in=True,
catalog=catalog,
dialog=ansible_tower_dialog,
catalog_items=ansible_catalog_item,
)
request.addfinalizer(catalog_bundle.delete_if_exists)
service_catalogs = ServiceCatalogs(appliance, catalog_bundle.catalog, catalog_bundle.name)
service_catalogs.order()
provision_request = appliance.collections.requests.instantiate(
bundle_name, partial_check=True)
provision_request.wait_for_request()
provision_request.remove_request(method="rest")
service = MyService(appliance, ansible_tower_dialog.label)
# Retire service
retire_request = service.retire()
assert retire_request.exists()
def test_reconfigure_service(provider, provisioning, catalog, catalog_item, request):
"""Tests stack provisioning
Metadata:
test_flag: provision
"""
catalog_item, item_name = catalog_item
stack_data = prepare_stack_data(provider, provisioning)
@request.addfinalizer
def _cleanup_vms():
try:
if provider.mgmt.stack_exist(stack_data['stack_name']):
wait_for(lambda: provider.mgmt.delete_stack(stack_data['stack_name']),
delay=10, num_sec=800, message="wait for stack delete")
stack_data['vm_name'].delete_from_provider()
except Exception as ex:
logger.warning('Exception while checking/deleting stack, continuing: {}'
.format(ex.message))
pass
service_catalogs = ServiceCatalogs(item_name, stack_data)
service_catalogs.order()
logger.info('Waiting for cfme provision request for service %s', item_name)
row_description = item_name
cells = {'Description': row_description}
row, __ = wait_for(requests.wait_for_request, [cells, True],
fail_func=requests.reload, num_sec=2000, delay=20)
assert provision_success_message(catalog_item.name) in row.last_message.text
myservice = MyService(catalog_item.name)
myservice.reconfigure_service()
def test_generic_object_with_service_button(appliance, generic_object,
button_with_dialog):
"""
Bugzilla:
1729341
1743266
Polarion:
assignee: jdupuy
initialEstimate: 1/6h
caseimportance: high
caseposneg: positive
testtype: functional
startsin: 5.10
casecomponent: GenericObjects
"""
# add generic object to service
myservice = MyService(
appliance, name=generic_object.associations.get("services")[0].name)
with appliance.context.use(ViaREST):
myservice.add_resource_generic_object(generic_object)
# now navigate to the details of the generic_object
view = navigate_to(generic_object, "MyServiceDetails")
view.toolbar.button(button_with_dialog.name).custom_button.click()
view = generic_object.create_view(TextInputDialogView, wait=10)
view.service_name.fill("Custom Button Execute")
wait_for(lambda: not view.submit.disabled, timeout="10s")
view.submit.click()
# now for the actual test, make sure after hitting submit we're on the correct page
try:
generic_object.create_view(MyServiceGenericObjectInstanceView, wait=10)
except TimedOutError:
pytest.fail(
"Could not wait for service's generic object view to displayed.")
def order_service(appliance, provider, provisioning, dialog, catalog, request):
""" Orders service once the catalog item is created"""
if hasattr(request, 'param'):
param = request.param
catalog_item = create_catalog_item(
appliance,
provider,
provisioning,
dialog,
catalog,
console_test=True if 'console_test' in param else None)
else:
catalog_item = create_catalog_item(appliance, provider, provisioning,
dialog, catalog)
service_catalogs = ServiceCatalogs(appliance, catalog_item.catalog,
catalog_item.name)
provision_request = service_catalogs.order()
provision_request.wait_for_request(method='ui')
assert provision_request.is_succeeded()
if provision_request.exists():
provision_request.wait_for_request()
if not BZ(1646333, forced_streams=['5.10']).blocks:
provision_request.remove_request()
yield catalog_item
service = MyService(appliance, catalog_item.name)
if service.exists:
service.delete()
vm_name = '{}0001'.format(catalog_item.prov_data['catalog']['vm_name'])
vm = appliance.collections.infra_vms.instantiate(vm_name, provider)
vm.cleanup_on_provider()
def test_retire_service(appliance, setup_provider, context,
order_catalog_item_in_ops_ui):
"""Test retire service."""
service_name = order_catalog_item_in_ops_ui.name
with appliance.context.use(context):
my_service = MyService(appliance, service_name)
my_service.retire()
def service_vm(appliance, provider, catalog_item):
""" This is global fixture to get service and vm/instance provision by service."""
collection = provider.appliance.provider_based_collection(provider)
vm_name = "{}0001".format(catalog_item.prov_data["catalog"]["vm_name"])
vm = collection.instantiate("{}".format(vm_name), provider)
service_catalogs = ServiceCatalogs(appliance, catalog_item.catalog,
catalog_item.name)
provision_request = service_catalogs.order()
logger.info("Waiting for service provision request for service %s",
catalog_item.name)
provision_request.wait_for_request()
if not provision_request.is_finished():
pytest.skip("Failed to provision service '{}'".format(
catalog_item.name))
service = MyService(appliance, catalog_item.name, vm_name=vm_name)
yield service, vm
vm.cleanup_on_provider()
if service.exists:
service.delete()
if provision_request.exists:
provision_request.remove_request(method="rest")
def order_service(appliance, provider, provisioning, dialog, catalog, request):
# BZ 1646333 - Delete this request button is not shown in service Request details page
# The above BZ got closed because of INSUFFICIENT_DATA, so I havve reported the same issue
# in BZ 775779.
""" Orders service once the catalog item is created"""
if hasattr(request, 'param'):
vm_count = request.param['vm_count'] if 'vm_count' in request.param else '1'
console_test = request.param['console_test'] if 'console_test' in request.param else False
catalog_item = create_catalog_item(appliance, provider, provisioning, dialog, catalog,
vm_count=vm_count, console_test=console_test)
else:
catalog_item = create_catalog_item(appliance, provider, provisioning, dialog, catalog)
service_catalogs = ServiceCatalogs(appliance, catalog_item.catalog, catalog_item.name)
provision_request = service_catalogs.order()
provision_request.wait_for_request(method='ui')
assert provision_request.is_succeeded()
if provision_request.exists():
provision_request.wait_for_request()
# Provision request is being removed through REST API because of BZ 775779.
provision_request.remove_request(method='rest')
yield catalog_item
service = MyService(appliance, catalog_item.name)
if service.exists:
service.delete()
name = catalog_item.prov_data['catalog']['vm_name']
for i in range(int(vm_count)):
vm_name = f'{name}000{i+1}'
vm = appliance.collections.infra_vms.instantiate(vm_name, provider)
vm.cleanup_on_provider()
def test_retire_ansible_service(appliance, catalog_item, request, job_type):
"""Tests retiring of catalog items for Ansible Template and Workflow jobs
Metadata:
test_flag: provision
Polarion:
assignee: nachandr
casecomponent: Services
caseimportance: medium
initialEstimate: 1/4h
"""
service_catalogs = ServiceCatalogs(appliance, 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}
order_request = appliance.collections.requests.instantiate(
cells=cells, partial_check=True)
order_request.wait_for_request(method='ui')
msg = "Request failed with the message {}".format(
order_request.row.last_message.text)
assert order_request.is_succeeded(method='ui'), msg
myservice = MyService(appliance, catalog_item.name)
myservice.retire()
def test_reconfigure_service(provider, provisioning, catalog, catalog_item,
request):
"""Tests stack provisioning
Metadata:
test_flag: provision
"""
catalog_item, template = catalog_item
stack_data = prepare_stack_data(provider, provisioning)
@request.addfinalizer
def _cleanup_vms():
clean_up(stack_data, provider)
service_catalogs = ServiceCatalogs(catalog_item.catalog, catalog_item.name,
stack_data)
service_catalogs.order()
logger.info('Waiting for cfme provision request for service {}'.format(
catalog_item.name))
row_description = catalog_item.name
cells = {'Description': row_description}
row, __ = wait_for(requests.wait_for_request, [cells, True],
fail_func=requests.reload,
num_sec=2000,
delay=20)
assert 'Provisioned Successfully' in row.last_message.text
myservice = MyService(catalog_item.name)
myservice.reconfigure_service()
def test_reconfigure_service(appliance, provider, provisioning, catalog, catalog_item, request):
"""Tests stack provisioning
Metadata:
test_flag: provision
"""
catalog_item, template = catalog_item
stack_data = prepare_stack_data(provider, provisioning)
@request.addfinalizer
def _cleanup_vms():
clean_up(stack_data, provider)
service_catalogs = ServiceCatalogs(appliance, catalog_item.catalog,
catalog_item.name, stack_data)
service_catalogs.order()
logger.info('Waiting for cfme provision request for service {}'.format(catalog_item.name))
request_description = catalog_item.name
provision_request = appliance.collections.requests.instantiate(request_description,
partial_check=True)
provision_request.wait_for_request()
assert provision_request.is_succeeded()
myservice = MyService(appliance, catalog_item.name)
myservice.reconfigure_service()
def _finalize():
_service = MyService(appliance, cat_item_name)
if service_request.exists():
service_request.wait_for_request()
appliance.rest_api.collections.service_requests.action.delete(id=service_id.id)
if _service.exists:
_service.delete()
def test_reconfigure_service(provider, provisioning, catalog, catalog_item, request):
"""Tests stack provisioning
Metadata:
test_flag: provision
"""
catalog_item, item_name = catalog_item
stack_data = prepare_stack_data(provider, provisioning)
@request.addfinalizer
def _cleanup_vms():
clean_up(stack_data, provider)
service_catalogs = ServiceCatalogs(item_name, stack_data)
service_catalogs.order()
logger.info('Waiting for cfme provision request for service {}'.format(item_name))
row_description = item_name
cells = {'Description': row_description}
row, __ = wait_for(requests.wait_for_request, [cells, True],
fail_func=requests.reload, num_sec=2000, delay=20)
assert 'Provisioned Successfully' in row.last_message.text
myservice = MyService(catalog_item.name)
myservice.reconfigure_service()
def order_retire_service(request, context, appliance, catalog_item):
"""Common method to order and then retire a service."""
with appliance:
# Order the service
provision_request = ServiceCatalogs(appliance,
catalog=catalog_item.catalog,
name=catalog_item.name).order()
provision_request.wait_for_request(method='ui')
assert provision_request.is_succeeded(method='ui')
service = MyService(appliance, catalog_item.dialog.label)
@request.addfinalizer
def _clear_request_service():
if provision_request.exists():
provision_request.remove_request()
if service.exists:
service.delete()
assert service.exists
# Retire the service via UI or REST, depending on context
with appliance.context.use(context):
retire_request = service.retire()
assert retire_request and retire_request.exists()
@request.addfinalizer
def _remove_retire_request():
retire_request.remove_request()
wait_for(lambda: service.is_retired,
delay=5,
num_sec=600,
fail_func=service.browser.refresh,
message="Waiting for service to retire")
def order_service(appliance, provider, provisioning, dialog, catalog, request):
""" Orders service once the catalog item is created"""
if hasattr(request, 'param'):
param = request.param
catalog_item = create_catalog_item(
appliance,
provider,
provisioning,
dialog,
catalog,
console_test=True if 'console_test' in param else None)
else:
catalog_item = create_catalog_item(appliance, provider, provisioning,
dialog, catalog)
service_catalogs = ServiceCatalogs(appliance, catalog_item.catalog,
catalog_item.name)
provision_request = service_catalogs.order()
provision_request.wait_for_request(method='ui')
assert provision_request.is_succeeded()
if provision_request.exists():
provision_request.wait_for_request()
provision_request.remove_request()
yield catalog_item
service = MyService(appliance, catalog_item.name)
if service.exists:
service.delete()
def _finalize():
_service = MyService(appliance, cat_item_name)
if service_request.exists():
service_request.wait_for_request()
service_request.remove_request()
if _service.exists:
_service.delete()
def test_retire_ansible_workflow(appliance, ansible_workflow_catitem,
workflow_type, ansible_api_version_change):
"""Tests retiring of catalog items for Ansible Workflow templates
Metadata:
test_flag: provision
Polarion:
assignee: jhenner
casecomponent: Services
caseimportance: medium
initialEstimate: 1/4h
"""
service_catalogs = ServiceCatalogs(appliance,
ansible_workflow_catitem.catalog,
ansible_workflow_catitem.name)
service_catalogs.order()
logger.info('Waiting for cfme provision request for service %s',
ansible_workflow_catitem.name)
cells = {'Description': ansible_workflow_catitem.name}
order_request = appliance.collections.requests.instantiate(
cells=cells, partial_check=True)
order_request.wait_for_request(method='ui')
msg = f"Request failed with the message {order_request.row.last_message.text}"
assert order_request.is_succeeded(method='ui'), msg
myservice = MyService(appliance, ansible_workflow_catitem.name)
myservice.retire()
def _finalize():
_service = MyService(appliance, cat_item_name)
if service_request.exists():
service_request.wait_for_request()
service_request.remove_request()
if _service.exists:
_service.delete()
def test_reconfigure_service(appliance, provider, provisioning, catalog,
catalog_item, request, stack_data):
"""Tests stack provisioning
Metadata:
test_flag: provision
"""
catalog_item, template = catalog_item
@request.addfinalizer
def _cleanup_vms():
clean_up(stack_data, provider)
service_catalogs = ServiceCatalogs(appliance, catalog_item.catalog,
catalog_item.name, stack_data)
service_catalogs.order()
logger.info('Waiting for cfme provision request for service {}'.format(
catalog_item.name))
request_description = catalog_item.name
provision_request = appliance.collections.requests.instantiate(
request_description, partial_check=True)
provision_request.wait_for_request(method='ui')
assert provision_request.is_succeeded()
last_message = provision_request.get_request_row_from_ui(
)['Last Message'].text
service_name = last_message.split()[2].strip('[]')
myservice = MyService(appliance, service_name)
myservice.reconfigure_service()
def _finalize():
_service = MyService(appliance, cat_item_name)
if service_request.exists():
service_request.wait_for_request()
appliance.rest_api.collections.service_requests.action.delete(
id=service_id.id)
if _service.exists:
_service.delete()
def test_myservice_crud(setup_provider, context, order_catalog_item_in_ops_ui):
"""Tests Myservice crud in SSUI."""
appliance = get_or_create_current_appliance()
service_name = order_catalog_item_in_ops_ui
with appliance.context.use(context):
appliance.server.login()
myservice = MyService(appliance, service_name)
myservice.update({'name': '{}_edited'.format(service_name)})
def service(appliance, ansible_catalog_item):
_service = MyService(appliance, ansible_catalog_item.name)
yield _service
try:
if _service.exists:
_service.delete()
except ItemNotFound:
pass
def _revert():
service = MyService(appliance, local_ansible_catalog_item.name)
if ansible_service_request.exists():
ansible_service_request.wait_for_request()
appliance.rest_api.collections.service_requests.action.delete(
id=service_request.id)
if service.exists:
service.delete()
def test_vm_console(appliance, setup_provider, context, configure_websocket,
order_catalog_item_in_ops_ui):
"""Tests Myservice VM Console in SSUI."""
service_name = order_catalog_item_in_ops_ui
with appliance.context.use(context):
appliance.server.login()
myservice = MyService(appliance, service_name)
myservice.launch_vm_console()
def test_service_link(appliance, context, myservice):
"""Tests service link from VM details page(BZ1443772)"""
service_name, vm_name = myservice
with appliance.context.use(context):
myservice = MyService(appliance, name=service_name, vm_name=vm_name)
view = navigate_to(myservice, 'VMDetails')
view.relationships.click_at("Service")
new_view = myservice.create_view(MyServiceDetailView)
assert new_view.is_displayed
def test_service_link(appliance, context, myservice):
"""Tests service link from VM details page(BZ1443772)"""
service_name, vm_name = myservice
with appliance.context.use(context):
myservice = MyService(appliance, name=service_name, vm_name=vm_name)
view = navigate_to(myservice, 'VMDetails')
view.summary('Relationships').click_at('Service')
new_view = myservice.create_view(MyServiceDetailView)
assert new_view.is_displayed
def test_service_provision_retire_from_global_region(request, replicated_appliances, provider,
context, catalog_item):
"""From the global appliance in a multi-region appliance configuration, order and then retire
a VM provisioning sevice on the remote appliance.
Polarion:
assignee: tpapaioa
caseimportance: high
casecomponent: Services
initialEstimate: 1/3h
"""
remote_appliance, global_appliance = replicated_appliances
with global_appliance:
# Order the service
provision_request = ServiceCatalogs(global_appliance, catalog_item.catalog,
catalog_item.name).order()
provision_request.wait_for_request(method='ui')
assert provision_request.is_succeeded(method='ui')
service = MyService(global_appliance, catalog_item.dialog.label)
@request.addfinalizer
def _clear_request_service():
if provision_request.exists():
provision_request.remove_request()
if service.exists:
service.delete()
assert service.exists
# Retire the service via UI or REST, depending on context
if context.name == 'UI':
retire_request = service.retire()
assert retire_request and retire_request.exists()
else:
# TODO: implement retire() via REST using sentaku context
services = global_appliance.rest_api.collections.services
api_service = services.get(name=service.name)
api_retire_requests = services.action.request_retire(api_service)
assert len(api_retire_requests) == 1
api_retire_request = api_retire_requests[0]
assert api_retire_request and api_retire_request.exists
retire_request = global_appliance.collections.requests.instantiate(
f'Service Retire for: {service.name}')
@request.addfinalizer
def _remove_retire_request():
retire_request.remove_request()
wait_for(lambda: service.is_retired, delay=5, num_sec=300,
fail_func=service.browser.refresh, message="Waiting for service to retire")
vm_name = f"{catalog_item.prov_data['catalog']['vm_name']}0001"
vm = global_appliance.provider_based_collection(provider).instantiate(vm_name, provider)
assert vm.wait_for_vm_state_change(from_any_provider=True, desired_state='archived')
def _cleanup(appliance=None, provision_request=None, service=None):
if not service:
last_message = provision_request.get_request_row_from_ui()['Last Message'].text
service_name = last_message.split()[2].strip('[]')
myservice = MyService(appliance, service_name)
else:
myservice = service
if myservice.exists:
myservice.delete()
def _cleanup(appliance=None, provision_request=None, service=None):
if not service:
last_message = provision_request.get_request_row_from_ui()['Last Message'].text
service_name = last_message.split()[2].strip('[]')
myservice = MyService(appliance, service_name)
else:
myservice = service
if myservice.exists:
myservice.delete()
def test_retire_service(appliance, context, myservice):
"""Tests my service
Metadata:
test_flag: provision
"""
service_name, vm_name = myservice
with appliance.context.use(context):
myservice = MyService(appliance, name=service_name, vm_name=vm_name)
myservice.retire()
def test_download_file(appliance, context, needs_firefox, myservice, filetype):
"""Tests my service download files
Metadata:
test_flag: provision
"""
service_name, vm_name = myservice
with appliance.context.use(context):
myservice = MyService(appliance, name=service_name, vm_name=vm_name)
myservice.download_file(filetype)
def test_download_file(appliance, context, needs_firefox, myservice, filetype):
"""Tests my service download files
Metadata:
test_flag: provision
"""
service_name, vm_name = myservice
with appliance.context.use(context):
myservice = MyService(appliance, name=service_name, vm_name=vm_name)
myservice.download_file(filetype)
def test_myservice_crud(appliance, setup_provider, context, provision_request):
"""Test Myservice crud in SSUI."""
catalog_item, provision_request = provision_request
with appliance.context.use(context):
my_service = MyService(appliance, catalog_item.name)
my_service.set_ownership("Administrator", "EvmGroup-approver")
my_service.update({'description': '{}_edited'.format(catalog_item.name)})
if appliance.version > "5.8":
my_service.edit_tags("Cost Center", "Cost Center 001")
my_service.delete()
def test_retire_service(appliance, context, myservice):
"""Tests my service
Metadata:
test_flag: provision
"""
service_name, vm_name = myservice
with appliance.context.use(context):
myservice = MyService(appliance, name=service_name, vm_name=vm_name)
myservice.retire()
def test_retire_service_on_date(appliance, context, myservice):
"""Tests my service retirement
Metadata:
test_flag: provision
"""
service_name, vm_name = myservice
with appliance.context.use(context):
myservice = MyService(appliance, name=service_name, vm_name=vm_name)
dt = datetime.utcnow()
myservice.retire_on_date(dt)
def test_retire_service_ssui(appliance, setup_provider,
context, order_service, request):
"""Test retire service."""
catalog_item = order_service
with appliance.context.use(context):
my_service = MyService(appliance, catalog_item.name)
my_service.retire()
@request.addfinalizer
def _finalize():
my_service.delete()
def test_retire_service_ssui(appliance, setup_provider,
context, order_service, request):
"""Test retire service."""
catalog_item = order_service
with appliance.context.use(context):
my_service = MyService(appliance, catalog_item.name)
my_service.retire()
@request.addfinalizer
def _finalize():
my_service.delete()
def test_myservice_crud(appliance, setup_provider, context, order_catalog_item_in_ops_ui):
"""Test Myservice crud in SSUI."""
service_name = order_catalog_item_in_ops_ui.name
with appliance.context.use(context):
my_service = MyService(appliance, service_name)
my_service.set_ownership("Administrator", "EvmGroup-approver")
my_service.update({'description': '{}_edited'.format(service_name)})
# No tag management in 5.7
if appliance.version > "5.8":
my_service.edit_tags("Cost Center", "Cost Center 001")
my_service.delete()
def test_retire_service_on_date(appliance, context, myservice):
"""Tests my service retirement
Metadata:
test_flag: provision
"""
service_name, vm_name = myservice
with appliance.context.use(context):
myservice = MyService(appliance, name=service_name, vm_name=vm_name)
dt = datetime.utcnow()
myservice.retire_on_date(dt)
def _revert():
with update(local_ansible_catalog_item):
local_ansible_catalog_item.provisioning = {
"playbook": "dump_all_variables.yml",
"cloud_type": "<Choose>",
}
service = MyService(appliance, local_ansible_catalog_item.name)
if service_request.exists():
service_request.wait_for_request()
appliance.rest_api.collections.service_requests.action.delete(id=service_id.id)
if service.exists:
service.delete()
def test_myservice_crud(appliance, setup_provider, context, order_service):
"""Test Myservice crud in SSUI."""
catalog_item = order_service
with appliance.context.use(context):
my_service = MyService(appliance, catalog_item.name)
my_service.set_ownership("Administrator", "EvmGroup-approver")
my_service.update({'description': '{}_edited'.format(catalog_item.name)})
if appliance.version > "5.8":
my_service.edit_tags("Cost Center", "Cost Center 001")
my_service.delete()
def test_retire_service_ui(appliance, context, myservice):
"""Tests my service
Metadata:
test_flag: provision
Polarion:
assignee: sshveta
initialEstimate: 1/4h
"""
service_name, vm_name = myservice
with appliance.context.use(context):
myservice = MyService(appliance, name=service_name, vm_name=vm_name)
myservice.retire()
def test_reconfigure_service(appliance, service_catalogs, request):
"""Tests service reconfiguring
Metadata:
test_flag: provision
"""
provision_request = service_catalogs.order()
provision_request.wait_for_request(method='ui')
last_message = provision_request.get_request_row_from_ui()['Last Message'].text
service_name = last_message.split()[2].strip('[]')
myservice = MyService(appliance, service_name)
request.addfinalizer(lambda: _cleanup(service=myservice))
assert provision_request.is_succeeded()
myservice.reconfigure_service()
def test_download_file(appliance, context, needs_firefox, myservice, filetype):
"""Tests my service download files
Metadata:
test_flag: provision
Polarion:
assignee: nansari
initialEstimate: 1/16h
"""
service_name, vm_name = myservice
with appliance.context.use(context):
myservice = MyService(appliance, name=service_name, vm_name=vm_name)
myservice.download_file(filetype)
def order_ansible_service_in_ops_ui(appliance, ansible_catalog_item,
ansible_service_catalog):
"""Tests if ansible playbook service provisioning is shown in service requests."""
ansible_service_catalog.order()
cat_item_name = ansible_catalog_item.name
request_descr = "Provisioning Service [{0}] from [{0}]".format(cat_item_name)
service_request = appliance.collections.requests.instantiate(description=request_descr)
if service_request.exists():
service_request.wait_for_request()
service_request.remove_request()
yield cat_item_name
service = MyService(appliance, cat_item_name)
if service.exists:
service.delete()
def test_retire_ansible_service(appliance, catalog_item, request):
"""Tests order catalog item
Metadata:
test_flag: provision
"""
catalog_item.create()
service_catalogs = ServiceCatalogs(appliance, 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}
order_request = appliance.collections.requests.instantiate(cells=cells, partial_check=True)
order_request.wait_for_request(method='ui')
assert order_request.is_succeeded(method='ui')
myservice = MyService(appliance, catalog_item.name)
myservice.retire()
def test_retire_ansible_service(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)
assert 'Provisioned Successfully' in row.last_message.text
myservice = MyService(catalog_item.name)
myservice.retire()
def test_retire_service_ui(appliance, context, myservice):
"""Tests my service
Metadata:
test_flag: provision
Polarion:
assignee: nansari
casecomponent: Services
initialEstimate: 1/4h
tags: service
"""
service_name, vm_name = myservice
with appliance.context.use(context):
myservice = MyService(appliance, name=service_name, vm_name=vm_name)
myservice.retire()
def test_service_start(appliance, setup_provider, context,
order_service, provider, request):
"""Test service stop
Metadata:
test_flag: ssui, services
"""
catalog_item = order_service
with appliance.context.use(context):
my_service = MyService(appliance, catalog_item.name)
if provider.one_of(InfraProvider, EC2Provider, AzureProvider):
# For Infra providers vm is provisioned.Hence Stop option is shown
# For Azure, EC2 Providers Instance is provisioned.Hence Stop option is shown
my_service.service_power(power='Stop')
view = my_service.create_view(DetailsMyServiceView)
wait_for(lambda: view.resource_power_status.power_status == 'Off',
timeout=1000,
fail_condition=None,
message='Wait for resources off',
delay=20)
else:
my_service.service_power(power='Start')
view = my_service.create_view(DetailsMyServiceView)
wait_for(lambda: view.resource_power_status.power_status == 'On',
timeout=1000,
fail_condition=None,
message='Wait for resources on',
delay=20)
@request.addfinalizer
def _finalize():
my_service.delete()
def myservice(appliance, provider, catalog_item, request):
vm_name = catalog_item.prov_data["catalog"]["vm_name"]
request.addfinalizer(lambda: VM.factory(vm_name + "_0001", provider).cleanup_on_provider())
service_catalogs = ServiceCatalogs(appliance, catalog_item.catalog, catalog_item.name)
service_catalogs.order()
logger.info('Waiting for cfme provision request for service %s', catalog_item.name)
request_description = catalog_item.name
provision_request = appliance.collections.requests.instantiate(request_description,
partial_check=True)
provision_request.wait_for_request()
assert provision_request.is_finished()
service = MyService(appliance, catalog_item.name, vm_name)
yield service
try:
service.delete()
except Exception as ex:
logger.warning('Exception while deleting MyService, continuing: {}'.format(ex.message))
def myservice(setup_provider, provider, catalog_item, request):
vm_name = catalog_item.provisioning_data["vm_name"]
request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider))
catalog_item.create()
service_catalogs = ServiceCatalogs(catalog_item.name)
service_catalogs.order()
logger.info("Waiting for cfme provision request for service %s", catalog_item.name)
row_description = catalog_item.name
cells = {"Description": row_description}
row, __ = wait_for(requests.wait_for_request, [cells, True], fail_func=requests.reload, num_sec=900, delay=20)
assert row.request_state.text == "Finished"
service = MyService(catalog_item.name, vm_name)
yield service
try:
service.delete()
except Exception as ex:
logger.warning("Exception while deleting MyService, continuing: {}".format(ex.message))
def test_retire_service_ssui(appliance, setup_provider,
context, order_service, request):
"""Test retire service.
Metadata:
test_flag: ssui, services
Polarion:
assignee: sshveta
initialEstimate: 1/4h
"""
catalog_item = order_service
with appliance.context.use(context):
my_service = MyService(appliance, catalog_item.name)
my_service.retire()
@request.addfinalizer
def _finalize():
my_service.delete()
def generic_service(appliance, generic_catalog_item):
""" This is global fixture to order generic service and return service and catalog item"""
service_catalogs = ServiceCatalogs(
appliance, catalog=generic_catalog_item.catalog, name=generic_catalog_item.name
)
provision_request = service_catalogs.order()
logger.info("Waiting for service provision request for service %s", generic_catalog_item.name)
provision_request.wait_for_request()
if not provision_request.is_finished():
pytest.skip("Failed to provision service '{}'".format(generic_catalog_item.name))
service = MyService(appliance, generic_catalog_item.dialog.label)
yield service, generic_catalog_item
if service.exists:
service.delete()
if provision_request.exists:
provision_request.remove_request(method="rest")
def test_reconfigure_service(provider, provisioning, create_template, catalog, request):
"""Tests stack provisioning
Metadata:
test_flag: provision
"""
dialog_name, template = create_template
item_name = fauxfactory.gen_alphanumeric()
catalog_item = CatalogItem(
item_type="Orchestration",
name=item_name,
description="my catalog",
display_in=True,
catalog=catalog.name,
dialog=dialog_name,
orch_template=template.template_name,
)
catalog_item.create()
stack_data = prepare_stack_data(provider, provisioning)
@request.addfinalizer
def _cleanup_vms():
if provider.mgmt.stack_exist(stack_data["stack_name"]):
wait_for(
lambda: provider.mgmt.delete_stack(stack_data["stack_name"]),
delay=10,
num_sec=800,
message="wait for stack delete",
)
template.delete_all_templates()
stack_data["vm_name"].delete_from_provider()
service_catalogs = ServiceCatalogs("service_name", stack_data)
service_catalogs.order_stack_item(catalog.name, catalog_item)
logger.info("Waiting for cfme provision request for service %s", item_name)
row_description = item_name
cells = {"Description": row_description}
row, __ = wait_for(requests.wait_for_request, [cells, True], fail_func=requests.reload, num_sec=2000, delay=20)
assert row.last_message.text == "Service Provisioned Successfully"
myservice = MyService(catalog_item.name)
myservice.reconfigure_service()
def test_myservice_crud(appliance, setup_provider, context, order_service):
"""Test Myservice crud in SSUI.
Metadata:
test_flag: ssui, services
Polarion:
assignee: sshveta
initialEstimate: 1/4h
"""
catalog_item = order_service
with appliance.context.use(context):
my_service = MyService(appliance, catalog_item.name)
my_service.set_ownership("Administrator", "EvmGroup-approver")
my_service.update({'description': '{}_edited'.format(catalog_item.name)})
my_service.edit_tags("Cost Center", "Cost Center 002")
my_service.delete()
def service_vm(appliance, provider, catalog_item):
""" This is global fixture to get service and vm/instance provision by service."""
collection = provider.appliance.provider_based_collection(provider)
vm_name = "{}0001".format(catalog_item.prov_data["catalog"]["vm_name"])
vm = collection.instantiate("{}0001".format(vm_name), provider)
service_catalogs = ServiceCatalogs(appliance, catalog_item.catalog, catalog_item.name)
provision_request = service_catalogs.order()
logger.info("Waiting for service provision request for service %s", catalog_item.name)
provision_request.wait_for_request()
if not provision_request.is_finished():
pytest.skip("Failed to provision service '{}'".format(catalog_item.name))
service = MyService(appliance, catalog_item.name, vm_name)
yield service, vm
vm.cleanup_on_provider()
if service.exists:
service.delete()
def test_retire_ansible_service(appliance, catalog_item, request, job_type):
"""Tests retiring of catalog items for Ansible Template and Workflow jobs
Metadata:
test_flag: provision
Polarion:
assignee: nachandr
casecomponent: Services
caseimportance: medium
initialEstimate: 1/4h
"""
service_catalogs = ServiceCatalogs(appliance, 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}
order_request = appliance.collections.requests.instantiate(cells=cells, partial_check=True)
order_request.wait_for_request(method='ui')
msg = "Request failed with the message {}".format(order_request.row.last_message.text)
assert order_request.is_succeeded(method='ui'), msg
myservice = MyService(appliance, catalog_item.name)
myservice.retire()
def test_service_link(appliance, context, myservice, provider):
"""Tests service link from VM details page(BZ1443772)
Polarion:
assignee: nansari
casecomponent: Services
initialEstimate: 1/4h
tags: service
"""
service_name, vm_name = myservice
with appliance.context.use(context):
# TODO: Update to nav to MyService first to click entity link when widget exists
myservice = MyService(appliance, name=service_name, vm_name=vm_name)
vm = appliance.provider_based_collection(coll_type='vms', provider=provider).instantiate(
name=myservice.vm_name,
provider=provider
)
view = navigate_to(vm, 'Details')
view.entities.summary('Relationships').click_at('Service')
new_view = myservice.create_view(MyServiceDetailView)
assert new_view.wait_displayed()
