def test_order_catalog_item(provider, setup_provider, catalog_item, request,
register_event):
"""Tests order catalog item
Metadata:
test_flag: provision
"""
vm_name = catalog_item.provisioning_data["vm_name"]
request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider))
catalog_item.create()
register_event(target_type='Service',
target_name=catalog_item.name,
event_type='service_provisioned')
service_catalogs = ServiceCatalogs(catalog_item.catalog, catalog_item.name)
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=1400,
delay=20)
assert row.request_state.text == 'Finished'
def test_retire_stack(provider, provisioning, catalog, catalog_item, request):
"""Tests stack provisioning
Metadata:
test_flag: provision
"""
catalog_item, template = catalog_item
DefaultView.set_default_view("Stacks", "Grid View")
stack_data = prepare_stack_data(provider, provisioning)
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))
request_description = catalog_item.name
provision_request = Request(request_description, partial_check=True)
provision_request.wait_for_request()
assert provision_request.is_succeeded()
stack = Stack(stack_data['stack_name'], provider=provider)
stack.wait_for_exists()
stack.retire_stack()
@request.addfinalizer
def _cleanup_vms():
clean_up(stack_data, provider)
def test_remove_template_provisioning(setup_provider, provider, provisioning,
dialog, catalog, request):
"""Tests stack provisioning
Metadata:
test_flag: provision
"""
dialog_name, template = dialog
method = METHOD_TORSO.replace('"Description" : "AWS',
'"Description" : "Amzn Web Services')
template.create(method)
template.create_service_dialog_from_template(dialog_name, template.template_name)
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,
provider_type=provider.name)
catalog_item.create()
stackname = "test-" + fauxfactory.gen_alphanumeric()
stack_data = {'stack_name': stackname}
service_catalogs = ServiceCatalogs("service_name", stack_data)
service_catalogs.order_stack_item(catalog.name, catalog_item)
# This is part of test - remove template and see if provision fails , so not added as finalizer
template.delete_all_templates()
row_description = 'Provisioning Service [{}] from [{}]'.format(item_name, item_name)
cells = {'Description': row_description}
wait_for(lambda: requests.find_request(cells), num_sec=500, delay=20)
row, __ = wait_for(requests.wait_for_request, [cells, True],
fail_func=requests.reload, num_sec=1000, delay=20)
assert row.last_message.text == 'Service_Template_Provisioning failed'
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_bundles_in_bundle(catalog_item):
bundle_name = "first_" + fauxfactory.gen_alphanumeric()
catalog_bundle = CatalogBundle(name=bundle_name, description="catalog_bundle",
display_in=True, catalog=catalog_item.catalog, dialog=catalog_item.dialog,
catalog_items=[catalog_item.name])
catalog_bundle.create()
sec_bundle_name = "sec_" + fauxfactory.gen_alphanumeric()
sec_catalog_bundle = CatalogBundle(name=sec_bundle_name, description="catalog_bundle",
display_in=True, catalog=catalog_item.catalog, dialog=catalog_item.dialog,
catalog_items=[bundle_name])
sec_catalog_bundle.create()
third_bundle_name = "third_" + fauxfactory.gen_alphanumeric()
third_catalog_bundle = CatalogBundle(name=third_bundle_name, description="catalog_bundle",
display_in=True, catalog=catalog_item.catalog, dialog=catalog_item.dialog,
catalog_items=[bundle_name, sec_bundle_name])
third_catalog_bundle.create()
service_catalogs = ServiceCatalogs(third_catalog_bundle.catalog, third_bundle_name)
service_catalogs.order()
flash.assert_no_errors()
logger.info('Waiting for cfme provision request for service %s', bundle_name)
row_description = third_bundle_name
cells = {'Description': row_description}
row, __ = wait_for(requests.wait_for_request, [cells, True],
fail_func=requests.reload, num_sec=900, delay=20)
# Success message differs between 5.6 and 5.7
if version.current_version() >= '5.7':
assert 'Provisioned Successfully' in row.last_message.text
else:
assert row.last_message.text == 'Request complete'
def myservice(setup_provider, provider, catalog_item, request):
"""Tests my service
Metadata:
test_flag: provision
"""
vm_name = version.pick({
version.LOWEST:
catalog_item.provisioning_data["vm_name"] + '_0001',
'5.7':
catalog_item.provisioning_data["vm_name"] + '0001'
})
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)
row_description = catalog_item.name
cells = {'Description': row_description}
row, __ = wait_for(requests.wait_for_request, [cells, True],
fail_func=tb.refresh,
num_sec=2000,
delay=60)
assert row.request_state.text == 'Finished'
yield MyService(catalog_item.name, vm_name)
cleanup_vm(vm_name, provider)
def test_order_catalog_bundle(provider, setup_provider, catalog_item, request):
"""Tests ordering a catalog bundle
Metadata:
test_flag: provision
"""
vm_name = catalog_item.provisioning_data["vm_name"]
request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider))
catalog_item.create()
bundle_name = fauxfactory.gen_alphanumeric()
catalog_bundle = CatalogBundle(name=bundle_name,
description="catalog_bundle",
display_in=True,
catalog=catalog_item.catalog,
dialog=catalog_item.dialog)
catalog_bundle.create([catalog_item.name])
service_catalogs = ServiceCatalogs("service_name")
service_catalogs.order(catalog_item.catalog, catalog_bundle)
flash.assert_no_errors()
logger.info('Waiting for cfme provision request for service %s' %
bundle_name)
row_description = bundle_name
cells = {'Description': row_description}
row, __ = wait_for(requests.wait_for_request, [cells, True],
fail_func=requests.reload,
num_sec=1200,
delay=20)
assert row.last_message.text == 'Request complete'
def test_retire_stack(provider, provisioning, create_template, catalog, request):
"""Tests stack provisioning
Metadata:
test_flag: provision
"""
set_default_view("Stacks", "Grid View")
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)
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=2500, delay=20)
assert row.last_message.text == 'Service Provisioned Successfully'
stack = Stack(stack_data['stack_name'])
stack.retire_stack()
@request.addfinalizer
def _cleanup_templates():
template.delete_all_templates()
stack_data['vm_name'].delete_from_provider()
def test_bundles_in_bundle(catalog_item):
bundle_name = "first_" + fauxfactory.gen_alphanumeric()
catalog_bundle = CatalogBundle(name=bundle_name, description="catalog_bundle",
display_in=True, catalog=catalog_item.catalog, dialog=catalog_item.dialog)
catalog_bundle.create([catalog_item.name])
sec_bundle_name = "sec_" + fauxfactory.gen_alphanumeric()
sec_catalog_bundle = CatalogBundle(name=sec_bundle_name, description="catalog_bundle",
display_in=True, catalog=catalog_item.catalog, dialog=catalog_item.dialog)
sec_catalog_bundle.create([bundle_name])
third_bundle_name = "third_" + fauxfactory.gen_alphanumeric()
third_catalog_bundle = CatalogBundle(name=third_bundle_name, description="catalog_bundle",
display_in=True, catalog=catalog_item.catalog, dialog=catalog_item.dialog)
third_catalog_bundle.create([bundle_name, sec_bundle_name])
service_catalogs = ServiceCatalogs(third_bundle_name)
service_catalogs.order()
flash.assert_no_errors()
logger.info('Waiting for cfme provision request for service %s', bundle_name)
row_description = third_bundle_name
cells = {'Description': row_description}
row, __ = wait_for(requests.wait_for_request, [cells, True],
fail_func=requests.reload, num_sec=900, delay=20)
# Success message differs between 5.6 and 5.7
if version.current_version() >= '5.7':
assert 'Service [{}] Provisioned Successfully'.format(third_bundle_name)\
in row.last_message.text
else:
assert row.last_message.text == 'Request complete'
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_retire_stack(provider, provisioning, catalog, catalog_item, request):
"""Tests stack provisioning
Metadata:
test_flag: provision
"""
catalog_item, item_name = catalog_item
DefaultView.set_default_view("Stacks", "Grid View")
stack_data = prepare_stack_data(provider, provisioning)
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=2500, delay=20)
assert provision_success_message(catalog_item.name) in row.last_message.text
stack = Stack(stack_data['stack_name'])
stack.wait_for_appear()
stack.retire_stack()
@request.addfinalizer
def _cleanup_templates():
try:
stack_data['vm_name'].delete_from_provider()
except Exception as ex:
logger.warning('Exception while checking/deleting stack, continuing: {}'
.format(ex.message))
pass
def myservice(setup_provider, provider, catalog_item, request):
"""Tests my service
Metadata:
test_flag: provision
"""
vm_name = version.pick({
version.LOWEST:
catalog_item.provisioning_data["vm_name"] + '_0001',
'5.7':
catalog_item.provisioning_data["vm_name"] + '0001'
})
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)
request_description = catalog_item.name
service_request = Request(request_description, partial_check=True)
service_request.wait_for_request()
assert service_request.is_succeeded()
yield MyService(catalog_item.name, vm_name)
cleanup_vm(vm_name, provider)
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 test_order_catalog_bundle(provider, setup_provider, catalog_item, request):
"""Tests ordering a catalog bundle
Metadata:
test_flag: provision
"""
vm_name = catalog_item.provisioning_data["vm_name"]
request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider))
catalog_item.create()
bundle_name = fauxfactory.gen_alphanumeric()
catalog_bundle = CatalogBundle(name=bundle_name,
description="catalog_bundle",
display_in=True,
catalog=catalog_item.catalog,
dialog=catalog_item.dialog,
catalog_items=[catalog_item.name])
catalog_bundle.create()
service_catalogs = ServiceCatalogs(catalog_item.catalog,
catalog_bundle.name)
service_catalogs.order()
logger.info("Waiting for cfme provision request for service {}".format(
bundle_name))
request_description = bundle_name
provision_request = Request(request_description, partial_check=True)
provision_request.wait_for_request()
assert provision_request.is_succeeded()
def test_remove_template_provisioning(provider, 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,
provider_type=provider.name)
catalog_item.create()
stackname = "test_" + fauxfactory.gen_alphanumeric()
stack_data = {'stack_name': stackname}
service_catalogs = ServiceCatalogs("service_name", stack_data)
service_catalogs.order_stack_item(catalog.name, catalog_item)
# This is part of test - remove template and see if provision fails , so not added as finalizer
template.delete_all_templates()
row_description = 'Provisioning Service [{}] from [{}]'.format(
item_name, item_name)
cells = {'Description': row_description}
wait_for(lambda: requests.find_request(cells), num_sec=500, delay=20)
row, __ = wait_for(requests.wait_for_request, [cells, True],
fail_func=requests.reload,
num_sec=1000,
delay=20)
assert row.last_message.text == 'Service_Template_Provisioning failed'
def test_bundles_in_bundle(catalog_item):
bundle_name = "first_" + fauxfactory.gen_alphanumeric()
catalog_bundle = CatalogBundle(name=bundle_name,
description="catalog_bundle",
display_in=True,
catalog=catalog_item.catalog,
dialog=catalog_item.dialog)
catalog_bundle.create([catalog_item.name])
sec_bundle_name = "sec_" + fauxfactory.gen_alphanumeric()
sec_catalog_bundle = CatalogBundle(name=sec_bundle_name,
description="catalog_bundle",
display_in=True,
catalog=catalog_item.catalog,
dialog=catalog_item.dialog)
sec_catalog_bundle.create([bundle_name])
third_bundle_name = "third_" + fauxfactory.gen_alphanumeric()
third_catalog_bundle = CatalogBundle(name=third_bundle_name,
description="catalog_bundle",
display_in=True,
catalog=catalog_item.catalog,
dialog=catalog_item.dialog)
third_catalog_bundle.create([bundle_name, sec_bundle_name])
service_catalogs = ServiceCatalogs("service_name")
service_catalogs.order(catalog_item.catalog, third_catalog_bundle)
flash.assert_no_errors()
logger.info('Waiting for cfme provision request for service %s' %
bundle_name)
row_description = third_bundle_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.last_message.text == 'Request complete'
def test_retire_stack(provider, provisioning, catalog, catalog_item, request):
"""Tests stack provisioning
Metadata:
test_flag: provision
"""
catalog_item, item_name = catalog_item
DefaultView.set_default_view("Stacks", "Grid View")
stack_data = prepare_stack_data(provider, provisioning)
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=2500, delay=20)
assert 'Provisioned Successfully' in row.last_message.text
stack = Stack(stack_data['stack_name'], provider=provider)
stack.wait_for_appear()
stack.retire_stack()
@request.addfinalizer
def _cleanup_vms():
clean_up(stack_data, provider)
def services(request, rest_api, a_provider, dialog, service_catalogs):
"""
The attempt to add the service entities via web
"""
template, host, datastore, iso_file, vlan, catalog_item_type = map(
a_provider.data.get("provisioning").get,
('template', 'host', 'datastore', 'iso_file', 'vlan',
'catalog_item_type'))
provisioning_data = {
'vm_name': 'test_rest_{}'.format(fauxfactory.gen_alphanumeric()),
'host_name': {
'name': [host]
},
'datastore_name': {
'name': [datastore]
}
}
if a_provider.type == 'rhevm':
provisioning_data['provision_type'] = 'Native Clone'
provisioning_data['vlan'] = vlan
catalog_item_type = "RHEV"
elif a_provider.type == 'virtualcenter':
provisioning_data['provision_type'] = 'VMware'
catalog = service_catalogs[0].name
item_name = fauxfactory.gen_alphanumeric()
catalog_item = CatalogItem(item_type=catalog_item_type,
name=item_name,
description="my catalog",
display_in=True,
catalog=catalog,
dialog=dialog.label,
catalog_name=template,
provider=a_provider.name,
prov_data=provisioning_data)
catalog_item.create()
service_catalogs = ServiceCatalogs("service_name")
service_catalogs.order(catalog_item.catalog, catalog_item)
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 row.last_message.text == 'Request complete'
try:
services = [_ for _ in rest_api.collections.services]
services[0]
except IndexError:
raise Exception("No options are selected")
@request.addfinalizer
def _finished():
services = [_ for _ in rest_api.collections.services]
if len(services) != 0:
rest_api.collections.services.action.delete(*services)
return services
def test_remove_template_provisioning(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)
service_catalogs = ServiceCatalogs("service_name", stack_data)
service_catalogs.order_stack_item(catalog.name, catalog_item)
# This is part of test - remove template and see if provision fails , so not added as finalizer
template.delete_all_templates()
row_description = "Provisioning Service [{}] from [{}]".format(item_name, item_name)
cells = {"Description": row_description}
wait_for(lambda: requests.find_request(cells), num_sec=500, delay=20)
row, __ = wait_for(requests.wait_for_request, [cells, True], fail_func=requests.reload, num_sec=1000, delay=20)
assert row.last_message.text == "Service_Template_Provisioning failed"
def test_ec2_catalog_item(provider_init, provider_key, provider_mgmt, provider_crud,
provider_type, provisioning, dialog, catalog, request):
# tries to delete the VM that gets created here
vm_name = 'test_ec2_servicecatalog-%s' % generate_random_string()
image = provisioning['image']['name']
item_name = "ec2_" + generate_random_string()
ec2_catalog_item = ec2.Instance(
item_type="Amazon",
name=item_name,
description="my catalog",
display_in=True,
catalog=catalog.name,
dialog=dialog,
catalog_name=image,
vm_name=vm_name,
instance_type=provisioning['instance_type'],
availability_zone=provisioning['availability_zone'],
security_groups=[provisioning['security_group']],
provider_mgmt=provider_mgmt,
provider=provider_crud.name,
guest_keypair="shared")
ec2_catalog_item.create()
service_catalogs = ServiceCatalogs("service_name")
service_catalogs.order(catalog.name, ec2_catalog_item)
flash.assert_no_errors()
logger.info('Waiting for cfme provision request for service %s' % item_name)
row_description = 'Provisioning [%s] for Service [%s]' % (item_name, item_name)
cells = {'Description': row_description}
request.addfinalizer(lambda: cleanup_vm(vm_name, provider_key, provider_mgmt))
row, __ = wait_for(requests.wait_for_request, [cells],
fail_func=requests.reload, num_sec=600, delay=20)
assert row.last_message.text == 'Request complete'
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))
request_description = catalog_item.name
provision_request = Request(request_description, partial_check=True)
provision_request.wait_for_request()
assert provision_request.is_succeeded()
myservice = MyService(catalog_item.name)
myservice.reconfigure_service()
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_retire_stack(provider, provisioning, catalog, catalog_item, request):
"""Tests stack provisioning
Metadata:
test_flag: provision
"""
catalog_item, template = catalog_item
DefaultView.set_default_view("Stacks", "Grid View")
stack_data = prepare_stack_data(provider, provisioning)
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=2500,
delay=20)
assert 'Provisioned Successfully' in row.last_message.text
stack = Stack(stack_data['stack_name'], provider=provider)
stack.wait_for_exists()
stack.retire_stack()
@request.addfinalizer
def _cleanup_vms():
clean_up(stack_data, provider)
def test_retire_stack(setup_provider, provider, provisioning,
dialog, catalog, request):
"""Tests stack provisioning
Metadata:
test_flag: provision
"""
set_default_view("Stacks", "Grid View")
dialog_name, template = dialog
method = METHOD_TORSO.replace('"Description" : "AWS',
'"Description" : "Aamzon Web Services desc')
template.create(method)
template.create_service_dialog_from_template(dialog_name, template.template_name)
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,
provider_type=provider.name)
catalog_item.create()
stackname = "test-" + fauxfactory.gen_alphanumeric()
stack_data = {'stack_name': stackname}
service_catalogs = ServiceCatalogs("service_name", stack_data)
service_catalogs.order_stack_item(catalog.name, catalog_item)
request.addfinalizer(lambda: template.delete_all_templates())
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=2500, delay=20)
assert row.last_message.text == 'Service Provisioned Successfully'
stack = Stack(stackname)
stack.retire_stack()
def test_dynamicdropdown_dialog(dialog, catalog):
item_name = fauxfactory.gen_alphanumeric()
catalog_item = CatalogItem(item_type="Generic", name=item_name,
description="my catalog", display_in=True, catalog=catalog.name,
dialog=dialog.label)
catalog_item.create()
service_catalogs = ServiceCatalogs("service_name")
service_catalogs.order(catalog_item.catalog, catalog_item)
def test_dynamicdropdown_dialog(dialog, catalog):
item_name = fauxfactory.gen_alphanumeric()
catalog_item = CatalogItem(item_type="Generic", name=item_name,
description="my catalog", display_in=True, catalog=catalog.name,
dialog=dialog.label)
catalog_item.create()
service_catalogs = ServiceCatalogs("service_name")
service_catalogs.order(catalog_item.catalog, catalog_item)
def test_provision_stack(setup_provider, provider, provisioning, dialog,
catalog, request):
"""Tests stack provisioning
Metadata:
test_flag: provision
"""
dialog_name, template_name = dialog
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_name,
provider_type=provider.name)
catalog_item.create()
stackname = "test-" + fauxfactory.gen_alphanumeric()
if provider.type == 'ec2':
stack_data = {
'stack_name':
stackname,
'key_name':
provisioning['stack_provisioning']['key_name'],
'db_user':
provisioning['stack_provisioning']['db_user'],
'db_password':
provisioning['stack_provisioning']['db_password'],
'db_root_password':
provisioning['stack_provisioning']['db_root_password'],
'select_instance_type':
provisioning['stack_provisioning']['instance_type'],
}
elif provider.type == 'openstack':
stack_data = {
'stack_name': stackname,
}
@request.addfinalizer
def _cleanup_vms():
if provider.mgmt.stack_exist(stackname):
provider.mgmt.delete_stack(stackname)
service_catalogs = ServiceCatalogs("service_name", stack_data)
service_catalogs.order_stack_item(catalog.name, catalog_item)
flash.assert_no_errors()
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=2500,
delay=20)
assert row.last_message.text == 'Service Provisioned Successfully'
def test_delete_catalog_deletes_service(dialog, catalog):
item_name = fauxfactory.gen_alphanumeric()
catalog_item = CatalogItem(item_type="Generic", name=item_name,
description="my catalog", display_in=True, catalog=catalog.name,
dialog=dialog)
catalog_item.create()
catalog.delete()
service_catalogs = ServiceCatalogs("service_name")
with error.expected(CandidateNotFound):
service_catalogs.order(catalog.name, catalog_item)
def test_delete_catalog_deletes_service(dialog, catalog):
item_name = fauxfactory.gen_alphanumeric()
catalog_item = CatalogItem(item_type="Generic", name=item_name,
description="my catalog", display_in=True, catalog=catalog,
dialog=dialog)
catalog_item.create()
catalog.delete()
service_catalogs = ServiceCatalogs(catalog, catalog_item.name)
with error.expected(NoSuchElementException):
service_catalogs.order()
def test_delete_catalog_deletes_service(dialog, catalog):
item_name = fauxfactory.gen_alphanumeric()
catalog_item = CatalogItem(item_type="Generic", name=item_name,
description="my catalog", display_in=True, catalog=catalog,
dialog=dialog)
catalog_item.create()
catalog.delete()
service_catalogs = ServiceCatalogs(catalog, catalog_item.name)
with error.expected(NoSuchElementException):
service_catalogs.order()
def test_delete_catalog_deletes_service(dialog, catalog):
item_name = fauxfactory.gen_alphanumeric()
catalog_item = CatalogItem(item_type="Generic", name=item_name,
description="my catalog", display_in=True, catalog=catalog.name,
dialog=dialog)
catalog_item.create()
catalog.delete()
service_catalogs = ServiceCatalogs("service_name")
with error.expected(CandidateNotFound):
service_catalogs.order(catalog.name, catalog_item)
def services(request, a_provider, rest_api, dialog, service_catalogs):
"""
The attempt to add the service entities via web
"""
template, host, datastore, iso_file, vlan, catalog_item_type = map(a_provider.data.get(
"provisioning").get,
('template', 'host', 'datastore', 'iso_file', 'vlan', 'catalog_item_type'))
provisioning_data = {
'vm_name': 'test_rest_{}'.format(fauxfactory.gen_alphanumeric()),
'host_name': {'name': [host]},
'datastore_name': {'name': [datastore]}
}
if a_provider.type == 'rhevm':
provisioning_data['provision_type'] = 'Native Clone'
provisioning_data['vlan'] = vlan
catalog_item_type = version.pick({
version.LATEST: "RHEV",
'5.3': "RHEV",
'5.2': "Redhat"
})
elif a_provider.type == 'virtualcenter':
provisioning_data['provision_type'] = 'VMware'
catalog = service_catalogs[0].name
item_name = fauxfactory.gen_alphanumeric()
catalog_item = CatalogItem(item_type=catalog_item_type, name=item_name,
description="my catalog", display_in=True,
catalog=catalog,
dialog=dialog.label,
catalog_name=template,
provider=a_provider.name,
prov_data=provisioning_data)
catalog_item.create()
service_catalogs = ServiceCatalogs("service_name")
service_catalogs.order(catalog_item.catalog, catalog_item)
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 row.last_message.text == 'Request complete'
try:
services = [_ for _ in rest_api.collections.services]
services[0]
except IndexError:
pytest.skip("There is no service to be taken")
@request.addfinalizer
def _finished():
services = [_ for _ in rest_api.collections.services]
if len(services) != 0:
rest_api.collections.services.action.delete(*services)
return services
def test_copy_request(setup_provider, provider, catalog_item, request):
"""Automate BZ 1194479"""
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.catalog, catalog_item.name)
service_catalogs.order()
request_description = catalog_item.name
service_request = Request(request_description, partial_check=True)
service_request.wait_for_request()
assert navigate_to(service_request, 'Details')
def test_copy_request(setup_provider, provider_key, provider_mgmt, catalog_item, request):
"""Automate BZ 1194479"""
vm_name = catalog_item.provisioning_data["vm_name"]
request.addfinalizer(lambda: cleanup_vm(vm_name, provider_key, provider_mgmt))
catalog_item.create()
service_catalogs = ServiceCatalogs("service_name")
service_catalogs.order(catalog_item.catalog, catalog_item)
row_description = catalog_item.name
cells = {"Description": row_description}
row, __ = wait_for(requests.wait_for_request, [cells, True], fail_func=requests.reload, num_sec=1800, delay=20)
requests.go_to_request(cells)
def create_vm(appliance, provider, setup_provider, catalog_item, request):
vm_name = catalog_item.provisioning_data["vm_name"]
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)
request_description = catalog_item.name
request_row = RequestCollection(appliance).instantiate(request_description, partial_check=True)
request_row.wait_for_request()
assert request_row.is_succeeded()
return vm_name
def create_vm(provider, setup_provider, catalog_item, request):
vm_name = catalog_item.provisioning_data["vm_name"]
catalog_item.create()
service_catalogs = ServiceCatalogs(catalog_item.name)
service_catalogs.order()
flash.assert_no_errors()
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=1400, delay=20)
assert row.last_message.text == "Request complete"
return vm_name
def test_cloud_catalog_item(setup_provider, provider, dialog, catalog, request,
provisioning):
"""Tests cloud catalog item
Metadata:
test_flag: provision
"""
vm_name = 'test{}'.format(fauxfactory.gen_alphanumeric())
# GCE accepts only lowercase letters in VM name
vm_name = vm_name.lower()
request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider))
image = provisioning['image']['name']
item_name = fauxfactory.gen_alphanumeric()
provisioning_data = dict(
vm_name=vm_name,
instance_type=provisioning['instance_type'],
security_groups=[provisioning['security_group']],
)
if provider.type == "azure":
updates = dict(
virtual_private_cloud=provisioning['virtual_private_cloud'],
cloud_subnet=provisioning['cloud_subnet'],
resource_group=[provisioning['resource_group']],
)
else:
updates = dict(availability_zone=provisioning['availability_zone'],
cloud_tenant=provisioning['cloud_tenant'],
cloud_network=provisioning['cloud_network'],
guest_keypair=provisioning['guest_keypair'],
boot_disk_size=provisioning['boot_disk_size'])
provisioning_data.update(updates)
catalog_item = CatalogItem(item_type=provisioning['item_type'],
name=item_name,
description="my catalog",
display_in=True,
catalog=catalog,
dialog=dialog,
catalog_name=image,
provider=provider,
prov_data=provisioning_data)
catalog_item.create()
service_catalogs = ServiceCatalogs(catalog_item.catalog, catalog_item.name)
service_catalogs.order()
flash.assert_no_errors()
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=1200,
delay=20)
assert row.request_state.text == 'Finished'
def test_order_catalog_item(provider_key, provider_mgmt, setup_providers, catalog_item, request):
vm_name = catalog_item.provisioning_data["vm_name"]
catalog_item.create()
service_catalogs = ServiceCatalogs("service_name")
service_catalogs.order(catalog_item.catalog, catalog_item)
flash.assert_no_errors()
logger.info('Waiting for cfme provision request for service %s' % catalog_item.name)
row_description = 'Provisioning [%s] for Service [%s]' % (catalog_item.name, catalog_item.name)
cells = {'Description': row_description}
request.addfinalizer(lambda: cleanup_vm(vm_name, provider_key, provider_mgmt))
row, __ = wait_for(requests.wait_for_request, [cells],
fail_func=requests.reload, num_sec=600, delay=20)
assert row.last_message.text == 'Request complete'
def create_vm(provider, setup_provider, catalog_item, request):
vm_name = catalog_item.provisioning_data["vm_name"]
catalog_item.create()
service_catalogs = ServiceCatalogs("service_name")
service_catalogs.order(catalog_item.catalog, catalog_item)
flash.assert_no_errors()
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=1400, delay=20)
assert row.last_message.text == 'Request complete'
return vm_name
def create_vm(provider_key, provider_mgmt, provider_init, catalog_item, request):
vm_name = catalog_item.provisioning_data["vm_name"]
catalog_item.create()
service_catalogs = ServiceCatalogs("service_name")
service_catalogs.order(catalog_item.catalog, catalog_item)
flash.assert_no_errors()
logger.info('Waiting for cfme provision request for service %s' % catalog_item.name)
row_description = 'Provisioning [%s] for Service [%s]' % (catalog_item.name, catalog_item.name)
cells = {'Description': row_description}
row, __ = wait_for(requests.wait_for_request, [cells],
fail_func=requests.reload, num_sec=900, delay=20)
assert row.last_message.text == 'Request complete'
return vm_name
def test_rhev_pxe_servicecatalog(provider_key, provider_mgmt, catalog_item, request):
vm_name = catalog_item.provisioning_data["vm_name"]
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' % catalog_item.name)
row_description = 'Provisioning [%s] for Service [%s]' % (catalog_item.name, catalog_item.name)
cells = {'Description': row_description}
request.addfinalizer(lambda: cleanup_vm(vm_name, provider_key, provider_mgmt))
row, __ = wait_for(requests.wait_for_request, [cells],
fail_func=requests.reload, num_sec=600, delay=20)
assert row.last_message.text == 'Request complete'
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("service_name")
service_catalogs.order(catalog_item.catalog.name, catalog_item)
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'
return MyService(catalog_item.name, vm_name)
def test_cloud_catalog_item(setup_provider, provider, dialog, catalog, request, provisioning):
"""Tests cloud catalog item
Metadata:
test_flag: provision
"""
vm_name = 'test{}'.format(fauxfactory.gen_alphanumeric())
# GCE accepts only lowercase letters in VM name
vm_name = vm_name.lower()
request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider))
image = provisioning['image']['name']
item_name = fauxfactory.gen_alphanumeric()
provisioning_data = dict(
vm_name=vm_name,
instance_type=provisioning['instance_type'],
security_groups=[provisioning['security_group']],
)
if provider.type == "azure":
updates = dict(
virtual_private_cloud=provisioning['virtual_private_cloud'],
cloud_subnet=provisioning['cloud_subnet'],
resource_group=[provisioning['resource_group']],
)
else:
updates = dict(
availability_zone=provisioning['availability_zone'],
cloud_tenant=provisioning['cloud_tenant'],
cloud_network=provisioning['cloud_network'],
guest_keypair=provisioning['guest_keypair'],
boot_disk_size=provisioning['boot_disk_size']
)
provisioning_data.update(updates)
catalog_item = CatalogItem(item_type=provisioning['item_type'],
name=item_name,
description="my catalog",
display_in=True,
catalog=catalog.name,
dialog=dialog,
catalog_name=image,
provider=provider,
prov_data=provisioning_data)
catalog_item.create()
service_catalogs = ServiceCatalogs(catalog_item.name)
service_catalogs.order()
flash.assert_no_errors()
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=1200, delay=20)
assert row.request_state.text == 'Finished'
def test_service_generic_catalog_bundle(appliance, catalog_item):
bundle_name = "generic_" + fauxfactory.gen_alphanumeric()
catalog_bundle = CatalogBundle(name=bundle_name, description="catalog_bundle",
display_in=True, catalog=catalog_item.catalog, dialog=catalog_item.dialog,
catalog_items=[catalog_item.name])
catalog_bundle.create()
service_catalogs = ServiceCatalogs(catalog_item.catalog, bundle_name)
service_catalogs.order()
logger.info('Waiting for cfme provision request for service %s', bundle_name)
request_description = bundle_name
provision_request = RequestCollection(appliance).instantiate(request_description,
partial_check=True)
provision_request.wait_for_request()
assert provision_request.is_succeeded()
def myservice(provider_init, provider_key, provider_mgmt, catalog_item, request):
vm_name = catalog_item.provisioning_data["vm_name"]
request.addfinalizer(lambda: cleanup_vm(vm_name, provider_key, provider_mgmt))
catalog_item.create()
service_catalogs = ServiceCatalogs("service_name")
service_catalogs.order(catalog_item.catalog, catalog_item)
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=900, delay=20)
assert row.last_message.text == 'Request complete'
return MyService(catalog_item.name, vm_name)
def test_copy_request(setup_provider, provider, catalog_item, request):
"""Automate BZ 1194479"""
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)
row_description = catalog_item.name
cells = {'Description': row_description}
row, __ = wait_for(requests.wait_for_request, [cells, True],
fail_func=requests.reload,
num_sec=1800,
delay=20)
requests.go_to_request(cells)
def test_order_tower_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)
assert 'Provisioned Successfully' in row.last_message.text
DefaultView.set_default_view("Configuration Management Providers", "List View")
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("service_name")
service_catalogs.order(catalog_item.catalog, catalog_item)
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=900, delay=20)
assert row.last_message.text == 'Request complete'
return MyService(catalog_item.name, vm_name)
def test_order_tower_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}
order_request = Request(cells=cells, partial_check=True)
order_request.wait_for_request(method='ui')
assert order_request.is_succeeded()
DefaultView.set_default_view("Configuration Management Providers", "List View")
def test_service_generic_catalog_bundle(catalog_item):
bundle_name = "generic_" + fauxfactory.gen_alphanumeric()
catalog_bundle = CatalogBundle(name=bundle_name, description="catalog_bundle",
display_in=True, catalog=catalog_item.catalog, dialog=catalog_item.dialog)
catalog_bundle.create([catalog_item.name])
service_catalogs = ServiceCatalogs("service_name")
service_catalogs.order(catalog_item.catalog, catalog_bundle)
flash.assert_no_errors()
logger.info('Waiting for cfme provision request for service %s', bundle_name)
row_description = bundle_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.last_message.text == 'Request complete'
def test_cloud_catalog_item(appliance, setup_provider, provider, dialog,
catalog, request, provisioning):
"""Tests cloud catalog item
Metadata:
test_flag: provision
"""
vm_name = 'test{}'.format(fauxfactory.gen_alphanumeric())
# GCE accepts only lowercase letters in VM name
vm_name = vm_name.lower()
request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider))
image = provisioning['image']['name']
item_name = fauxfactory.gen_alphanumeric()
provisioning_data = dict(
vm_name=vm_name,
instance_type=provisioning['instance_type'],
security_groups=[provisioning['security_group']],
)
if provider.type == "azure":
updates = dict(
virtual_private_cloud=provisioning['virtual_private_cloud'],
cloud_subnet=provisioning['cloud_subnet'],
resource_group=[provisioning['resource_group']],
)
else:
updates = dict(availability_zone=provisioning['availability_zone'],
cloud_tenant=provisioning['cloud_tenant'],
cloud_network=provisioning['cloud_network'],
guest_keypair=provisioning['guest_keypair'],
boot_disk_size=provisioning['boot_disk_size'])
provisioning_data.update(updates)
catalog_item = CatalogItem(item_type=provisioning['item_type'],
name=item_name,
description="my catalog",
display_in=True,
catalog=catalog,
dialog=dialog,
catalog_name=image,
provider=provider,
prov_data=provisioning_data)
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', item_name)
request_description = item_name
provision_request = RequestCollection(appliance).instantiate(
request_description, partial_check=True)
provision_request.wait_for_request()
assert provision_request.if_succeeded()
def test_cloud_catalog_item(setup_provider, provider, dialog, catalog, request, provisioning):
"""Tests cloud catalog item
Metadata:
test_flag: provision
"""
vm_name = 'test_servicecatalog-{}'.format(fauxfactory.gen_alphanumeric())
request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider))
image = provisioning['image']['name']
item_name = fauxfactory.gen_alphanumeric()
data = dict(
item_type=provisioning['item_type'],
name=item_name,
description="my catalog",
display_in=True,
catalog=catalog.name,
dialog=dialog,
catalog_name=image,
vm_name=vm_name,
provider_mgmt=provider.mgmt,
provider=provider.name,
instance_type=provisioning['instance_type'],
security_groups=[provisioning['security_group']],
)
if provider.type == "azure":
updates = dict(
virtual_private_cloud=provisioning['virtual_private_cloud'],
cloud_subnet=provisioning['cloud_subnet'],
resource_group=[provisioning['resource_group']],
)
else:
updates = dict(
availability_zone=provisioning['availability_zone'],
cloud_tenant=provisioning['cloud_tenant'],
cloud_network=provisioning['cloud_network'],
guest_keypair=provisioning['guest_keypair']
)
data.update(updates)
cloud_catalog_item = cct.Instance(**data)
cloud_catalog_item.create()
service_catalogs = ServiceCatalogs("service_name")
service_catalogs.order(catalog.name, cloud_catalog_item)
flash.assert_no_errors()
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=1000, delay=20)
assert row.last_message.text == 'Request complete'
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_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}
order_request = Request(cells=cells, partial_check=True)
order_request.wait_for_request(method='ui')
assert order_request.is_succeeded()
myservice = MyService(catalog_item.name)
myservice.retire()
def test_order_catalog_item(catalog_item, request):
"""Tests order catalog item
Metadata:
test_flag: provision
"""
catalog_item.create()
service_catalogs = ServiceCatalogs("service_name")
service_catalogs.order(catalog_item.catalog, catalog_item)
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=1400, delay=20)
assert row.last_message.text == 'Service Provisioned Successfully'
set_default_view("Configuration Management Providers", "List View")
def test_reconfigure_service(setup_provider, provider, provisioning, dialog,
catalog, request):
"""Tests stack provisioning
Metadata:
test_flag: provision
"""
dialog_name, template = dialog
method = METHOD_TORSO.replace('"Description" : "AWS',
'"Description" : "Amzn Web')
template.create(method)
template.create_service_dialog_from_template(dialog_name,
template.template_name)
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,
provider_type=provider.name)
catalog_item.create()
stackname = "test-" + fauxfactory.gen_alphanumeric()
stack_data = {'stack_name': stackname}
@request.addfinalizer
def _cleanup_vms():
if provider.mgmt.stack_exist(stackname):
wait_for(lambda: provider.mgmt.delete_stack(stackname),
delay=10,
num_sec=800,
message="wait for stack delete")
template.delete_all_templates()
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_tagdialog_catalog_item(provider, setup_provider, catalog_item, request):
"""Tests tag dialog catalog item
Metadata:
test_flag: provision
"""
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=1400, delay=20)
assert row.request_state.text == 'Finished'
def test_order_catalog_item(provider, setup_provider, catalog_item, request, register_event):
"""Tests order catalog item
Metadata:
test_flag: 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)
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=1400, delay=20)
assert row.last_message.text == 'Request complete'
register_event('Service', catalog_item.name, 'service_provisioned')
def test_request_with_orphaned_template(provider, setup_provider, catalog_item):
"""Tests edit catalog item after deleting provider
Metadata:
test_flag: provision
"""
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}
provider.delete(cancel=False)
provider.wait_for_delete()
requests.go_to_request(cells)
row, __ = wait_for(requests.wait_for_request, [cells, True],
fail_func=requests.reload, num_sec=1800, delay=20)
assert row.status.text == 'Error'
def test_pxe_servicecatalog(setup_provider, provider, catalog_item, request):
"""Tests RHEV PXE service catalog
Metadata:
test_flag: pxe, provision
"""
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()
# nav to requests page happens on successful provision
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=3100, delay=20)
assert row.last_message.text == 'Request complete'