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 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 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_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_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_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 _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()