def finalize(): policy_for_testing.assign_events() with update(policy_for_testing): policy_for_testing.scope = ( "fill_field(VM and Instance : Name, INCLUDES, {})".format(vm_name)) with update(compliance_policy): compliance_policy.scope = ( "fill_field(VM and Instance : Name, INCLUDES, {})".format(vm_name)) cleanup_vm(clone_vm_name, provider)
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.type == "rhevm": provision_type = "Native Clone" elif provider.type == "virtualcenter": provision_type = "VMware" vm.clone_vm("*****@*****.**", "first", "last", clone_vm_name, provision_type) row_description = clone_vm_name cells = {"Description": row_description} row, __ = wait_for(requests.wait_for_request, [cells, True], fail_func=requests.reload, num_sec=4000, delay=20) assert row.last_message.text == "Vm Provisioned Successfully"
def _provisioner(template, provisioning_data, delayed=None): pytest.sel.force_navigate('infrastructure_provision_vms', context={ 'provider': provider, 'template_name': template, }) vm_name = provisioning_data["vm_name"] fill(provisioning_form, provisioning_data, action=provisioning_form.submit_button) flash.assert_no_errors() request.addfinalizer(lambda: cleanup_vm(vm_name, provider)) if delayed is not None: total_seconds = (delayed - datetime.utcnow()).total_seconds() row_description = 'Provision from [{}] to [{}]'.format(template, vm_name) cells = {'Description': row_description} try: row, __ = wait_for(requests.wait_for_request, [cells], fail_func=requests.reload, 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], 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) row_description = 'Provision from [{}] to [{}]'.format(template, vm_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 == 'Vm Provisioned Successfully' return VM.factory(vm_name, provider)
def test_iso_provision_from_template(appliance, provider, vm_name, smtp_test, datastore_init, request, setup_provider): """Tests ISO provisioning Metadata: test_flag: iso, provision suite: infra_provisioning """ # generate_tests makes sure these have values iso_template, host, datastore, iso_file, iso_kickstart,\ iso_root_password, iso_image_type, vlan = map(provider.data['provisioning'].get, ('pxe_template', 'host', 'datastore', 'iso_file', 'iso_kickstart', 'iso_root_password', 'iso_image_type', 'vlan')) request.addfinalizer(lambda: cleanup_vm(vm_name, provider)) provisioning_data = { 'catalog': { 'vm_name': vm_name, 'provision_type': 'ISO', 'iso_file': {'name': iso_file}}, 'environment': { 'host_name': {'name': host}, 'datastore_name': {'name': datastore}}, 'customize': { 'custom_template': {'name': iso_kickstart}, 'root_password': iso_root_password}, 'network': { 'vlan': vlan}} do_vm_provisioning(appliance, iso_template, provider, vm_name, provisioning_data, request, smtp_test, num_sec=1500)
def test_provision_from_template(appliance, setup_provider, provider, vm_name, smtp_test, request, provisioning, auto): """ Tests provisioning from a template Metadata: test_flag: provision suite: infra_provisioning rbac: roles: default: evmgroup-super_administrator: evmgroup-administrator: evmgroup-operator: NoSuchElementException evmgroup-auditor: NoSuchElementException """ template = provisioning['template'] request.addfinalizer(lambda: cleanup_vm(vm_name, provider)) provisioning_data = { 'catalog': { 'vm_name': vm_name }, 'environment': {'vm_name': vm_name, 'host_name': {'name': provisioning['host']} if not auto else None, 'datastore_name': {'name': provisioning['datastore']} if not auto else None, 'automatic_placement': True if auto else None}, 'network': {'vlan': provisioning['vlan']}} do_vm_provisioning(appliance, template, provider, vm_name, provisioning_data, request, smtp_test, num_sec=900)
def _provisioner(template, provisioning_data, delayed=None): vm = Vm(name=vm_name, provider=provider, template_name=template) view = navigate_to(vm, 'Provision') view.form.fill_with(provisioning_data, on_change=view.form.submit_button) base_view = vm.appliance.browser.create_view(BaseLoggedInPage) base_view.flash.assert_no_error() request.addfinalizer(lambda: cleanup_vm(vm_name, provider)) request_description = 'Provision from [{}] to [{}]'.format(template, vm_name) provision_request = appliance.collections.requests.instantiate( 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_pxe_provision_from_template(provider, vm_name, smtp_test, setup_provider, request, setup_pxe_servers_vm_prov): """Tests provisioning via PXE Metadata: test_flag: pxe, provision suite: infra_provisioning """ # generate_tests makes sure these have values pxe_template, host, datastore, pxe_server, pxe_image, pxe_kickstart,\ pxe_root_password, pxe_image_type, pxe_vlan = map(provider.data['provisioning'].get, ('pxe_template', 'host', 'datastore', 'pxe_server', 'pxe_image', 'pxe_kickstart', 'pxe_root_password', 'pxe_image_type', 'vlan')) request.addfinalizer(lambda: cleanup_vm(vm_name, provider)) provisioning_data = { 'vm_name': vm_name, 'host_name': {'name': [host]}, 'datastore_name': {'name': [datastore]}, 'provision_type': 'PXE', 'pxe_server': pxe_server, 'pxe_image': {'name': [pxe_image]}, 'custom_template': {'name': [pxe_kickstart]}, 'root_password': pxe_root_password, 'vlan': pxe_vlan, } do_vm_provisioning(pxe_template, provider, vm_name, provisioning_data, request, smtp_test, num_sec=2100)
def test_iso_provision_from_template(provider, provisioning, vm_name, smtp_test, datastore_init, request, setup_provider): """Tests ISO provisioning Metadata: test_flag: iso, provision suite: infra_provisioning """ # generate_tests makes sure these have values iso_template, host, datastore, iso_file, iso_kickstart,\ iso_root_password, iso_image_type, vlan = map(provisioning.get, ('pxe_template', 'host', 'datastore', 'iso_file', 'iso_kickstart', 'iso_root_password', 'iso_image_type', 'vlan')) request.addfinalizer(lambda: cleanup_vm(vm_name, provider)) provisioning_data = { 'vm_name': vm_name, 'host_name': {'name': [host]}, 'datastore_name': {'name': [datastore]}, 'provision_type': 'ISO', 'iso_file': {'name': [iso_file]}, 'custom_template': {'name': [iso_kickstart]}, 'root_password': iso_root_password, 'vlan': vlan, } do_vm_provisioning(iso_template, provider, vm_name, provisioning_data, request, smtp_test, num_sec=1500)
def test_order_catalog_item_via_rest( request, appliance, provider, setup_provider, catalog_item, catalog): """Same as :py:func:`test_order_catalog_item`, but using REST. Metadata: test_flag: provision, rest """ vm_name = catalog_item.provisioning_data['catalog']["vm_name"] request.addfinalizer(lambda: cleanup_vm(vm_name, provider)) catalog_item.create() request.addfinalizer(catalog_item.delete) catalog = appliance.rest_api.collections.service_catalogs.find_by(name=catalog.name) assert len(catalog) == 1 catalog, = catalog template = catalog.service_templates.find_by(name=catalog_item.name) assert len(template) == 1 template, = template req = template.action.order() assert appliance.rest_api.response.status_code == 200 @wait_for_decorator(timeout="15m", delay=5) def request_finished(): req.reload() logger.info("Request status: {}, Request state: {}, Request message: {}".format( req.status, req.request_state, req.message)) return req.status.lower() == "ok" and req.request_state.lower() == "finished"
def ssa_vm(request, local_setup_provider, provider, vm_analysis_provisioning_data, appliance, analysis_type): """ Fixture to provision instance on the provider """ vm_name = 'test-ssa-{}-{}'.format(fauxfactory.gen_alphanumeric(), analysis_type) vm = VM.factory(vm_name, provider, template_name=vm_analysis_provisioning_data.image) request.addfinalizer(lambda: cleanup_vm(vm_name, provider)) provision_data = vm_analysis_provisioning_data.copy() del provision_data['image'] vm.create_on_provider(find_in_cfme=True, **provision_data) if provider.one_of(OpenStackProvider): public_net = provider.data['public_network'] vm.provider.mgmt.assign_floating_ip(vm.name, public_net) logger.info("VM %s provisioned, waiting for IP address to be assigned", vm_name) @wait_for_decorator(timeout="20m", delay=5) def get_ip_address(): logger.info("Power state for {} vm: {}, is_vm_stopped: {}".format( vm_name, provider.mgmt.vm_status(vm_name), provider.mgmt.is_vm_stopped(vm_name))) if provider.mgmt.is_vm_stopped(vm_name): provider.mgmt.start_vm(vm_name) ip = provider.mgmt.current_ip_address(vm_name) logger.info("Fetched IP for %s: %s", vm_name, ip) return ip is not None connect_ip = provider.mgmt.get_ip_address(vm_name) assert connect_ip is not None # Check that we can at least get the uptime via ssh this should only be possible # if the username and password have been set via the cloud-init script so # is a valid check if vm_analysis_provisioning_data['fs-type'] not in ['ntfs', 'fat32']: logger.info("Waiting for %s to be available via SSH", connect_ip) ssh_client = ssh.SSHClient( hostname=connect_ip, username=vm_analysis_provisioning_data['username'], password=vm_analysis_provisioning_data['password'], port=22) wait_for(ssh_client.uptime, num_sec=3600, handle_exception=True) vm.ssh = ssh_client vm.system_type = detect_system_type(vm) logger.info("Detected system type: %s", vm.system_type) vm.image = vm_analysis_provisioning_data['image'] vm.connect_ip = connect_ip # TODO: if rhev and iscsi, it need direct_lun if provider.type == 'rhevm': logger.info("Setting a relationship between VM and appliance") cfme_rel = VM.CfmeRelationship(vm) server_name = appliance.server.name cfme_rel.set_relationship(str(server_name), configuration.server_id()) yield vm # Close the SSH client if we have one if getattr(vm, 'ssh', None): vm.ssh.close()
def test_vm_clone(appliance, provider, clone_vm_name, request, create_vm): request.addfinalizer(lambda: cleanup_vm(clone_vm_name, provider)) provision_type = 'VMware' create_vm.clone_vm("*****@*****.**", "first", "last", clone_vm_name, provision_type) request_description = clone_vm_name request_row = appliance.collections.requests.instantiate(request_description, partial_check=True) request_row.wait_for_request(method='ui') assert request_row.is_succeeded(method='ui')
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 = { 'catalog': {'vm_name': vm_name, }, 'properties': {'instance_type': provisioning['instance_type'], }, 'environment': {'security_groups': [provisioning['security_group']], }, } if provider.type == "azure": env_updates = dict( cloud_network=provisioning['virtual_private_cloud'], cloud_subnet=provisioning['cloud_subnet'], resource_groups=[provisioning['resource_group']], ) else: provisioning_data['properties']['guest_keypair'] = provisioning['guest_keypair'] provisioning_data['properties']['boot_disk_size'] = provisioning['boot_disk_size'] env_updates = dict( availability_zone=provisioning['availability_zone'], cloud_tenant=provisioning['cloud_tenant'], cloud_network=provisioning['cloud_network']) provisioning_data['environment'].update(env_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(appliance, 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 = appliance.collections.requests.instantiate(request_description, partial_check=True) provision_request.wait_for_request() assert provision_request.is_succeeded()
def myservice(appliance, setup_provider, provider, catalog_item, request): """Tests my service Metadata: test_flag: provision """ vm_name = catalog_item.provisioning_data["catalog"]["vm_name"] + '0001' 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) request_description = catalog_item.name service_request = appliance.collections.requests.instantiate(request_description, partial_check=True) service_request.wait_for_request() assert service_request.is_succeeded() yield catalog_item.name, vm_name cleanup_vm(vm_name, provider)
def test_copy_request(appliance, setup_provider, provider, catalog_item, request): """Automate BZ 1194479""" vm_name = catalog_item.provisioning_data["catalog"]["vm_name"] request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider)) catalog_item.create() service_catalogs = ServiceCatalogs(appliance, catalog_item.catalog, catalog_item.name) service_catalogs.order() request_description = catalog_item.name service_request = appliance.collections.requests.instantiate(request_description, partial_check=True) service_request.wait_for_request() assert navigate_to(service_request, 'Details')
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 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 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_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_action_cancel_clone(request, provider, assign_policy_for_testing_vm_big, vm_big): """This test checks if 'Cancel vCenter task' action works. For this test we need big template otherwise CFME won't have enough time to cancel the task https://bugzilla.redhat.com/show_bug.cgi?id=1383372#c9 """ assign_policy_for_testing_vm_big.assign_events("VM Clone Start") assign_policy_for_testing_vm_big.assign_actions_to_event( "VM Clone Start", ["Cancel vCenter Task"]) clone_vm_name = "{}-clone".format(vm_big.name) request.addfinalizer(lambda: assign_policy_for_testing_vm_big.assign_events()) request.addfinalizer(lambda: cleanup_vm(clone_vm_name, provider)) vm_big.crud.clone_vm(fauxfactory.gen_email(), "first", "last", clone_vm_name, "VMware") cells = {"Description": clone_vm_name} row, __ = wait_for(requests.wait_for_request, [cells, True], fail_func=requests.reload, num_sec=4000, delay=20) assert row.status.text == "Error"
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_service_manual_approval(appliance, provider, setup_provider, modify_instance, catalog_item, request): """Tests order catalog item Metadata: test_flag: provision """ vm_name = catalog_item.provisioning_data['catalog']["vm_name"] request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider)) 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 {}".format(catalog_item.name)) request_description = catalog_item.name service_request = appliance.collections.requests.instantiate(description=request_description, partial_check=True) service_request.update(method='ui') assert service_request.row.approval_state.text == 'Pending Approval'
def test_pxe_servicecatalog(appliance, setup_provider, provider, catalog_item, request): """Tests RHEV PXE service catalog Metadata: test_flag: pxe, provision """ vm_name = catalog_item.provisioning_data['catalog']["vm_name"] request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider)) catalog_item.create() service_catalogs = ServiceCatalogs(appliance, 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 = appliance.collections.requests.instantiate(request_description, partial_check=True) provision_request.wait_for_request(num_sec=3600) assert provision_request.is_succeeded()
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_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'
def test_provision_cloud_init(setup_provider, provider, setup_ci_template, provisioning, vm_name, smtp_test, request): """Tests cloud init provisioning Metadata: test_flag: cloud_init, provision suite: infra_provisioning """ # generate_tests makes sure these have values template = provisioning.get('ci-image', None) or provisioning['image']['name'] host, datastore = map(provisioning.get, ('host', 'datastore')) mgmt_system = provider.get_mgmt_system() request.addfinalizer(lambda: cleanup_vm(vm_name, provider)) provisioning_data = { 'vm_name': vm_name, 'host_name': {'name': [host]}, 'datastore_name': {'name': [datastore]}, 'provision_type': 'Native Clone', 'custom_template': {'name': [provisioning['ci-template']]}, } try: provisioning_data['vlan'] = provisioning['vlan'] except KeyError: # provisioning['vlan'] is required for rhevm provisioning if provider.type == 'rhevm': raise pytest.fail('rhevm requires a vlan value in provisioning info') do_vm_provisioning(template, provider, vm_name, provisioning_data, request, smtp_test, num_sec=900) connect_ip, tc = wait_for(mgmt_system.get_ip_address, [vm_name], num_sec=300, handle_exception=True) # Check that we can at least get the uptime via ssh this should only be possible # if the username and password have been set via the cloud-init script so # is a valid check sshclient = ssh.SSHClient(hostname=connect_ip, username=provisioning['ci-username'], password=provisioning['ci-pass']) wait_for(sshclient.uptime, num_sec=200, handle_exception=True)
def myservice(setup_provider, provider, catalog_item, request): """Tests my service Metadata: test_flag: provision """ vm_name = catalog_item.provisioning_data["vm_name"] + "_0001" request.addfinalizer(lambda: cleanup_vm(vm_name, 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=2000, delay=20) assert row.last_message.text == 'Request complete' return MyService(catalog_item.name, vm_name)
def test_rhev_iso_servicecatalog(appliance, setup_provider, provider, catalog_item, request): """Tests RHEV ISO service catalog Metadata: test_flag: iso, provision """ vm_name = catalog_item.provisioning_data['catalog']["vm_name"] request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider)) catalog_item.create() service_catalogs = ServiceCatalogs(appliance, 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 = appliance.collections.requests.instantiate(request_description, partial_check=True) provision_request.wait_for_request() msg = "Provisioning failed with the message {}".format(provision_request.rest.message) assert provision_request.is_succeeded(), msg
def myservice(appliance, setup_provider, provider, catalog_item, request): vm_name = catalog_item.provisioning_data["catalog"]["vm_name"] request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider)) 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) 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 test_cloud_catalog_item(appliance, vm_name, setup_provider, provider, dialog, catalog, request, provisioning): """Tests cloud catalog item Metadata: test_flag: provision """ wait_for(provider.is_refreshed, func_kwargs=dict(refresh_delta=10), timeout=600) request.addfinalizer( lambda: cleanup_vm("{}0001".format(vm_name), provider)) image = provisioning['image']['name'] item_name = "{}-service-{}".format(provider.name, fauxfactory.gen_alphanumeric()) inst_args = { 'catalog': { 'catalog_name': { 'name': image, 'provider': provider.name }, 'vm_name': vm_name }, 'environment': { 'availability_zone': provisioning.get('availability_zone', None), 'security_groups': [provisioning.get('security_group', None)], 'cloud_tenant': provisioning.get('cloud_tenant', None), 'cloud_network': provisioning.get('cloud_network', None), 'cloud_subnet': provisioning.get('cloud_subnet', None), 'resource_groups': provisioning.get('resource_group', None) }, 'properties': { 'instance_type': partial_match(provisioning.get('instance_type', None)), 'guest_keypair': provisioning.get('guest_keypair', None) } } # GCE specific if provider.one_of(GCEProvider): recursive_update( inst_args, { 'properties': { 'boot_disk_size': provisioning['boot_disk_size'], 'is_preemptible': True } }) # Azure specific if provider.one_of(AzureProvider): recursive_update( inst_args, { 'customize': { 'admin_username': provisioning['customize_username'], 'root_password': provisioning['customize_password'] } }) catalog_item = appliance.collections.catalog_items.create( provider.catalog_item_type, name=item_name, description="my catalog", display_in=True, catalog=catalog, dialog=dialog, prov_data=inst_args) request.addfinalizer(catalog_item.delete) service_catalogs = ServiceCatalogs(appliance, 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 = appliance.collections.requests.instantiate( request_description, partial_check=True) provision_request.wait_for_request() msg = "Request failed with the message {}".format( provision_request.rest.message) assert provision_request.is_succeeded(), msg
def test_provision_approval(appliance, 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(appliance, 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 = appliance.collections.requests.instantiate(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 }, 'Description': 'Provision from [{}] to [{}]'.format(template, 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)
def instance(request, local_setup_provider, provider, vm_name, vm_analysis_data): """ Fixture to provision instance on the provider """ template = vm_analysis_data.get('image', None) host_name, datastore_name = map(vm_analysis_data.get, ('host', 'datastore')) mgmt_system = provider.get_mgmt_system() provisioning_data = { 'vm_name': vm_name, 'host_name': { 'name': [host_name] }, 'datastore_name': { 'name': [datastore_name] }, } try: provisioning_data['vlan'] = vm_analysis_data['vlan'] except KeyError: # provisioning['vlan'] is required for rhevm provisioning if provider.type == 'rhevm': raise pytest.fail( 'rhevm requires a vlan value in provisioning info') vm = VM.factory(vm_name, provider) connect_ip = None if provider.type == "openstack": image = vm_analysis_data['image'] vm = VM.factory(vm_name, provider, image) request.addfinalizer(vm.delete_from_provider) connect_ip = mgmt_system.get_first_floating_ip() provider.refresh_provider_relationships(method='ui') inst_args = { 'email': '*****@*****.**', 'first_name': 'Image', 'last_name': 'Provisioner', 'template_name': image, 'notes': ('Testing provisioning from image {} to vm {} on provider {}'. format(image, vm_name, provider.key)), 'instance_type': vm_analysis_data['instance_type'], 'availability_zone': vm_analysis_data['availability_zone'], 'security_groups': [vm_analysis_data['security_group']], 'cloud_network': vm_analysis_data['cloud_network'], 'public_ip_address': connect_ip, } vm.create(**inst_args) else: request.addfinalizer(lambda: cleanup_vm(vm_name, provider)) do_vm_provisioning(template, provider, vm_name, provisioning_data, request, None, num_sec=6000) logger.info("VM %s provisioned, waiting for IP address to be assigned", vm_name) @pytest.wait_for(timeout="20m", delay=5) def get_ip_address(): logger.info("Power state for {} vm: {}, is_vm_stopped: {}".format( vm_name, mgmt_system.vm_status(vm_name), mgmt_system.is_vm_stopped(vm_name))) if mgmt_system.is_vm_stopped(vm_name): mgmt_system.start_vm(vm_name) ip = mgmt_system.current_ip_address(vm_name) logger.info("Fetched IP for %s: %s", vm_name, ip) return ip is not None connect_ip = mgmt_system.get_ip_address(vm_name) assert connect_ip is not None # Check that we can at least get the uptime via ssh this should only be possible # if the username and password have been set via the cloud-init script so # is a valid check if vm_analysis_data['fs-type'] not in ['ntfs', 'fat32']: logger.info("Waiting for %s to be available via SSH", connect_ip) ssh_client = ssh.SSHClient(hostname=connect_ip, username=vm_analysis_data['username'], password=vm_analysis_data['password'], port=22) wait_for(ssh_client.uptime, num_sec=3600, handle_exception=False) vm.ssh = ssh_client vm.system_type = detect_system_type(vm) logger.info("Detected system type: %s", vm.system_type) vm.image = vm_analysis_data['image'] vm.connect_ip = connect_ip if provider.type == 'rhevm': logger.info("Setting a relationship between VM and appliance") from cfme.infrastructure.virtual_machines import Vm cfme_rel = Vm.CfmeRelationship(vm) cfme_rel.set_relationship(str(configuration.server_name()), configuration.server_id()) return vm
def instance(request, local_setup_provider, provider, vm_name, vm_analysis_data, appliance): """ Fixture to provision instance on the provider """ vm = VM.factory(vm_name, provider, template_name=vm_analysis_data['image']) request.addfinalizer(lambda: cleanup_vm(vm_name, provider)) provision_data = vm_analysis_data.copy() del provision_data['image'] vm.create_on_provider(find_in_cfme=True, **provision_data) if provider.type == "openstack": vm.provider.mgmt.assign_floating_ip(vm.name, 'public') logger.info("VM %s provisioned, waiting for IP address to be assigned", vm_name) mgmt_system = provider.get_mgmt_system() @wait_for_decorator(timeout="20m", delay=5) def get_ip_address(): logger.info("Power state for {} vm: {}, is_vm_stopped: {}".format( vm_name, mgmt_system.vm_status(vm_name), mgmt_system.is_vm_stopped(vm_name))) if mgmt_system.is_vm_stopped(vm_name): mgmt_system.start_vm(vm_name) ip = mgmt_system.current_ip_address(vm_name) logger.info("Fetched IP for %s: %s", vm_name, ip) return ip is not None connect_ip = mgmt_system.get_ip_address(vm_name) assert connect_ip is not None # Check that we can at least get the uptime via ssh this should only be possible # if the username and password have been set via the cloud-init script so # is a valid check if vm_analysis_data['fs-type'] not in ['ntfs', 'fat32']: logger.info("Waiting for %s to be available via SSH", connect_ip) ssh_client = ssh.SSHClient(hostname=connect_ip, username=vm_analysis_data['username'], password=vm_analysis_data['password'], port=22) wait_for(ssh_client.uptime, num_sec=3600, handle_exception=True) vm.ssh = ssh_client vm.system_type = detect_system_type(vm) logger.info("Detected system type: %s", vm.system_type) vm.image = vm_analysis_data['image'] vm.connect_ip = connect_ip # TODO: This is completely wrong and needs to be fixed # CFME relationship is suppose to be set to the appliance, which is required # to be placed within the same datastore that the VM resides # # Also, if rhev and iscsi, it need direct_lun if provider.type == 'rhevm': logger.info("Setting a relationship between VM and appliance") from cfme.infrastructure.virtual_machines import Vm cfme_rel = Vm.CfmeRelationship(vm) server_name = appliance.server_name() cfme_rel.set_relationship(str(server_name), configuration.server_id()) yield vm # Close the SSH client if we have one if getattr(vm, 'ssh', None): vm.ssh.close()
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 = { 'vm_name': vm_name, 'host_name': {'name': [host]}, 'datastore_name': {'name': [datastore]}, 'num_vms': "2", } # Same thing, different names. :\ if provider.type == 'rhevm': provisioning_data['provision_type'] = 'Native Clone' elif provider.type == 'virtualcenter': provisioning_data['provision_type'] = 'VMware' try: provisioning_data['vlan'] = provisioning['vlan'] except KeyError: # provisioning['vlan'] is required for rhevm provisioning if provider.type == 'rhevm': raise pytest.fail('rhevm requires a vlan value in provisioning info') 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)} wait_for(lambda: requests.go_to_request(cells), num_sec=80, delay=5) if edit: # Automatic approval after editing the request to conform with requests.edit_request(cells) as form: fill(form.num_vms, "1") new_vm_name = vm_name + "-xx" fill(form.vm_name, new_vm_name) vm_names = [new_vm_name] # Will be just one now cells = {'Description': 'Provision from [{}] to [{}]'.format(template, new_vm_name)} request.addfinalizer( lambda: cleanup_vm(new_vm_name, provider)) else: # Manual approval requests.approve_request(cells, "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) row, __ = wait_for(requests.wait_for_request, [cells], fail_func=requests.reload, num_sec=1500, delay=20) assert normalize_text(row.status.text) == 'ok' \ and normalize_text(row.request_state.text) == 'finished' # 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)
def finalize(): policy_for_testing.assign_events() with update(policy_for_testing): policy_for_testing.scope = ( "fill_field(VM and Instance : Name, INCLUDES, {})".format(vm_name)) cleanup_vm(clone_vm_name, provider)
def test_cloud_catalog_item(appliance, setup_provider, provider, dialog, catalog, request, provisioning): """Tests cloud catalog item Metadata: test_flag: provision """ # azure accepts only 15 chars vm name vm_name = 'test{}'.format(fauxfactory.gen_string('alphanumeric', 5)) # 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 = { 'catalog': { 'vm_name': vm_name, }, 'properties': { 'instance_type': partial_match(provisioning['instance_type']), }, 'environment': {} } if not provider.one_of(GCEProvider): provisioning_data['environment'].update( {'security_groups': partial_match(provisioning['security_group'])}) if not provider.one_of(AzureProvider) and not provider.one_of(GCEProvider): provisioning_data['environment'].update( {'cloud_tenant': provisioning['cloud_tenant']}) if provider.one_of(AzureProvider): env_updates = dict( cloud_network=partial_match(provisioning['virtual_private_cloud']), cloud_subnet=provisioning['cloud_subnet'], resource_groups=provisioning['resource_group'], ) provisioning_data['environment'].update(env_updates) provisioning_data.update({ 'customize': { 'admin_username': provisioning['customize_username'], 'root_password': provisioning['customize_password'] } }) else: provisioning_data['properties']['guest_keypair'] = provisioning[ 'guest_keypair'] provisioning_data['properties']['boot_disk_size'] = provisioning[ 'boot_disk_size'] env_updates = dict(availability_zone=provisioning['availability_zone'], cloud_network=provisioning['cloud_network']) provisioning_data['environment'].update(env_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(appliance, 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 = appliance.collections.requests.instantiate( request_description, partial_check=True) provision_request.wait_for_request() assert provision_request.is_succeeded()