def test_provision_from_template(provider, testing_instance, soft_assert): """ Tests instance provision from template Metadata: test_flag: provision """ instance, inst_args, image = testing_instance instance.create(**inst_args) logger.info('Waiting for cfme provision request for vm %s', instance.name) request_description = 'Provision from [{}] to [{}]'.format( image, instance.name) provision_request = Request(request_description) try: provision_request.wait_for_request(method='ui') except Exception as e: logger.info("Provision failed {}: {}".format( e, provision_request.row.last_message.text())) raise e assert provision_request.is_succeeded(method='ui'), \ "Provisioning failed with the message {}".format(provision_request.row.last_message.text) instance.wait_to_appear(timeout=800) provider.refresh_provider_relationships() logger.info("Refreshing provider relationships and power states") refresh_timer = RefreshTimer(time_for_refresh=300) wait_for(provider.is_refreshed, [refresh_timer], message="is_refreshed", num_sec=1000, delay=60, handle_exception=True) soft_assert(instance.does_vm_exist_on_provider(), "Instance wasn't provisioned")
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 _provisioner(template, provisioning_data, delayed=None): vm = Vm(name=vm_name, provider=provider, template_name=template) view = navigate_to(vm, 'Provision') view.form.before_fill(provisioning_data) fill(provisioning_form, provisioning_data, action=provisioning_form.submit_button) flash.assert_no_errors() request.addfinalizer(lambda: cleanup_vm(vm_name, provider)) request_description = 'Provision from [{}] to [{}]'.format(template, vm_name) provision_request = Request(description=request_description) if delayed is not None: total_seconds = (delayed - datetime.utcnow()).total_seconds() try: wait_for(provision_request.is_finished, fail_func=provision_request.update, num_sec=total_seconds, delay=5) pytest.fail("The provisioning was not postponed") except TimedOutError: pass logger.info('Waiting for vm %s to appear on provider %s', vm_name, provider.key) wait_for( provider.mgmt.does_vm_exist, [vm_name], fail_func=provider.refresh_provider_relationships, handle_exception=True, num_sec=600 ) # nav to requests page happens on successful provision logger.info('Waiting for cfme provision request for vm %s', vm_name) provision_request.wait_for_request() assert provision_request.is_succeeded(method='ui') return vm
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 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, 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 do_vm_provisioning(template_name, provider, vm_name, provisioning_data, request, smtp_test, num_sec=1500, wait=True): # generate_tests makes sure these have values vm = Vm(name=vm_name, provider=provider, template_name=template_name) note = ('template {} to vm {} on provider {}'.format( template_name, vm_name, provider.key)) provisioning_data.update({ 'request': { 'email': '*****@*****.**', 'first_name': 'Template', 'last_name': 'Provisioner', 'notes': note } }) view = navigate_to(vm, 'Provision') view.form.fill_with(provisioning_data, on_change=view.form.submit_button) flash.assert_no_errors() if not wait: return # Provision Re important in this test logger.info('Waiting for cfme provision request for vm %s', vm_name) request_description = 'Provision from [{}] to [{}]'.format( template_name, vm_name) provision_request = Request(request_description) provision_request.wait_for_request(method='ui') assert provision_request.is_succeeded(method='ui'), \ "Provisioning failed with the message {}".format(provision_request.row.last_message.text) # Wait for the VM to appear on the provider backend before proceeding to ensure proper cleanup logger.info('Waiting for vm %s to appear on provider %s', vm_name, provider.key) wait_for(provider.mgmt.does_vm_exist, [vm_name], handle_exception=True, num_sec=600) if smtp_test: # Wait for e-mails to appear def verify(): approval = dict( subject_like= "%%Your Virtual Machine configuration was Approved%%") expected_text = "Your virtual machine request has Completed - VM:%%{}".format( vm_name) return (len(smtp_test.get_emails(**approval)) > 0 and len(smtp_test.get_emails(subject_like=expected_text)) > 0) wait_for(verify, message="email receive check", delay=30)
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) request_description = catalog_item.name request_row = Request(request_description, partial_check=True) request_row.wait_for_request() assert request_row.is_succeeded() return 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_vm_clone(provider, clone_vm_name, request, create_vm): vm_name = create_vm + "_0001" request.addfinalizer(lambda: cleanup_vm(vm_name, provider)) request.addfinalizer(lambda: cleanup_vm(clone_vm_name, provider)) vm = VM.factory(vm_name, provider) if provider.one_of(RHEVMProvider): provision_type = 'Native Clone' elif provider.one_of(VMwareProvider): provision_type = 'VMware' vm.clone_vm("*****@*****.**", "first", "last", clone_vm_name, provision_type) request_description = clone_vm_name request_row = Request(request_description, partial_check=True) request_row.wait_for_request(method='ui') assert request_row.is_succeeded(method='ui')
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_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.catalog, 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) request_description = catalog_item.name provision_request = Request(request_description, partial_check=True) provision_request.wait_for_request() assert provision_request.is_succeeded()
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_items=[catalog_item.name]) catalog_bundle.create() service_catalogs = ServiceCatalogs(catalog_item.catalog, bundle_name) service_catalogs.order() flash.assert_no_errors() logger.info('Waiting for cfme provision request for service %s', 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_vm_migrate(new_vm, provider): """Tests migration of a vm Metadata: test_flag: migrate, provision """ # auto_test_services should exist to test migrate VM vm_host = new_vm.get_detail(properties=('Relationships', 'Host')) migrate_to = [ vds.name for vds in provider.hosts if vds.name not in vm_host ][0] new_vm.migrate_vm("*****@*****.**", "first", "last", host_name=migrate_to) flash.assert_no_errors() request_description = new_vm.name cells = {'Description': request_description, 'Request Type': 'Migrate'} migrate_request = Request(request_description, cells=cells, partial_check=True) migrate_request.wait_for_request(method='ui') assert migrate_request.is_succeeded(method='ui')
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)) request_description = catalog_item.name provision_request = Request(request_description, partial_check=True) provision_request.wait_for_request() assert provision_request.is_succeeded()
def test_provision_approval( setup_provider, provider, vm_name, smtp_test, request, edit, provisioning): """ Tests provisioning approval. Tests couple of things. * Approve manually * Approve by editing the request to conform Prerequisities: * A provider that can provision. * Automate role enabled * User with e-mail set so you can receive and view them Steps: * Create a provisioning request that does not get automatically approved (eg. ``num_vms`` bigger than 1) * Wait for an e-mail to come, informing you that the auto-approval was unsuccessful. * Depending on whether you want to do manual approval or edit approval, do: * MANUAL: manually approve the request in UI * EDIT: Edit the request in UI so it conforms the rules for auto-approval. * Wait for an e-mail with approval * Wait until the request finishes * Wait until an email, informing about finished provisioning, comes. Metadata: test_flag: provision suite: infra_provisioning """ # generate_tests makes sure these have values template, host, datastore = map(provisioning.get, ('template', 'host', 'datastore')) # It will provision two of them vm_names = [vm_name + "001", vm_name + "002"] request.addfinalizer( lambda: [cleanup_vm(vmname, provider) for vmname in vm_names]) provisioning_data = { 'catalog': { 'vm_name': vm_name, 'num_vms': '2'}, 'environment': {'host_name': {'name': provisioning['host']}, 'datastore_name': {'name': provisioning['datastore']}}, 'network': {'vlan': provisioning['vlan']}} do_vm_provisioning(template, provider, vm_name, provisioning_data, request, smtp_test, wait=False) wait_for( lambda: len(filter( lambda mail: "your request for a new vms was not autoapproved" in normalize_text(mail["subject"]), smtp_test.get_emails())) > 0, num_sec=90, delay=5) wait_for( lambda: len(filter( lambda mail: "virtual machine request was not approved" in normalize_text(mail["subject"]), smtp_test.get_emails())) > 0, num_sec=90, delay=5) cells = {'Description': 'Provision from [{}] to [{}###]'.format(template, vm_name)} provision_request = Request(cells=cells) navigate_to(provision_request, 'Details') if edit: # Automatic approval after editing the request to conform new_vm_name = vm_name + "-xx" modifications = {'catalog': {'num_vms': "1", 'vm_name': new_vm_name}} provision_request.edit_request(values=modifications) vm_names = [new_vm_name] # Will be just one now request.addfinalizer( lambda: cleanup_vm(new_vm_name, provider)) else: # Manual approval provision_request.approve_request(method='ui', reason="Approved") vm_names = [vm_name + "001", vm_name + "002"] # There will be two VMs request.addfinalizer( lambda: [cleanup_vm(vmname, provider) for vmname in vm_names]) wait_for( lambda: len(filter( lambda mail: "your virtual machine configuration was approved" in normalize_text(mail["subject"]), smtp_test.get_emails())) > 0, num_sec=120, delay=5) # Wait for the VM to appear on the provider backend before proceeding to ensure proper cleanup logger.info('Waiting for vms %s to appear on provider %s', ", ".join(vm_names), provider.key) wait_for( lambda: all(map(provider.mgmt.does_vm_exist, vm_names)), handle_exception=True, num_sec=600) provision_request.wait_for_request(method='ui') assert provision_request.is_succeeded(method='ui') # Wait for e-mails to appear def verify(): return ( len(filter( lambda mail: "your virtual machine request has completed vm {}".format(normalize_text(vm_name)) in normalize_text(mail["subject"]), smtp_test.get_emails())) == len(vm_names) ) wait_for(verify, message="email receive check", delay=5)