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 test_project_quota_enforce_via_lifecycle_infra(appliance, provider, new_user, set_project_quota, extra_msg, custom_prov_data, approve, prov_data, vm_name, template_name): """Test project quota via lifecycle method Polarion: assignee: ghubale casecomponent: Configuration initialEstimate: 1/4h tags: quota """ with new_user: recursive_update(prov_data, custom_prov_data) do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name, provisioning_data=prov_data, wait=False, request=None) # nav to requests page to check quota validation request_description = 'Provision from [{template}] to [{vm}{msg}]'.format( template=template_name, vm=vm_name, msg=extra_msg) provision_request = appliance.collections.requests.instantiate( request_description) if approve: provision_request.approve_request(method='ui', reason="Approved") provision_request.wait_for_request(method='ui') assert provision_request.row.reason.text == "Quota Exceeded"
def test_project_quota_enforce_via_lifecycle_infra(appliance, provider, setup_provider, new_user, set_project_quota, extra_msg, custom_prov_data, approve, prov_data, vm_name, template_name): """Test project quota via lifecycle method Metadata: test_flag: quota Polarion: assignee: ghubale casecomponent: Configuration initialEstimate: 1/4h """ with new_user: recursive_update(prov_data, custom_prov_data) do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name, provisioning_data=prov_data, wait=False, request=None) # nav to requests page to check quota validation request_description = 'Provision from [{}] to [{}{}]'.format(template_name, vm_name, extra_msg) provision_request = appliance.collections.requests.instantiate(request_description) if approve: provision_request.approve_request(method='ui', reason="Approved") provision_request.wait_for_request(method='ui') assert provision_request.row.reason.text == "Quota Exceeded"
def test_iso_provision_from_template(provider_key, provider_crud, provider_type, provider_mgmt, provisioning, vm_name, smtp_test, provider_init, request): """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_key, provider_mgmt)) 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_crud, vm_name, provisioning_data, request, provider_mgmt, provider_key, smtp_test, num_sec=1500)
def test_user_quota_diff_groups(request, appliance, provider, setup_provider, new_user, set_parent_tenant_quota, extra_msg, custom_prov_data, approve, prov_data, vm_name, template_name): """prerequisite: Provider should be added steps: 1. Provision VM with more than assigned quota Polarion: assignee: ghubale initialEstimate: 1/4h casecomponent: Quota """ with new_user: recursive_update(prov_data, custom_prov_data) logger.info("Successfully updated VM provisioning data") do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name, provisioning_data=prov_data, wait=False, request=None) # nav to requests page to check quota validation request_description = 'Provision from [{}] to [{}{}]'.format(template_name, vm_name, extra_msg) provision_request = appliance.collections.requests.instantiate(request_description) if approve: provision_request.approve_request(method='ui', reason="Approved") provision_request.wait_for_request(method='ui') assert provision_request.row.reason.text == "Quota Exceeded"
def test_project_quota_enforce_via_lifecycle_infra(appliance, provider, setup_provider, new_user, set_project_quota, extra_msg, custom_prov_data, approve, prov_data, vm_name, template_name): """Test project quota via lifecycle method Metadata: test_flag: quota """ with new_user: recursive_update(prov_data, custom_prov_data) do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name, provisioning_data=prov_data, smtp_test=False, wait=False, request=None) # nav to requests page to check quota validation request_description = 'Provision from [{}] to [{}{}]'.format( template_name, vm_name, extra_msg) provision_request = appliance.collections.requests.instantiate( request_description) if approve: provision_request.approve_request(method='ui', reason="Approved") provision_request.wait_for_request(method='ui') assert provision_request.row.reason.text == "Quota Exceeded"
def test_quota_tagging_infra_via_lifecycle(request, appliance, provider, set_entity_quota_tag, custom_prov_data, vm_name, template_name, prov_data): """ Polarion: assignee: ghubale casecomponent: Quota caseimportance: medium initialEstimate: 1/6h tags: quota """ recursive_update(prov_data, custom_prov_data) do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name, provisioning_data=prov_data, wait=False, request=None) # nav to requests page to check quota validation request_description = 'Provision from [{template}] to [{vm}]'.format( template=template_name, vm=vm_name) provision_request = appliance.collections.requests.instantiate( request_description) provision_request.wait_for_request(method='ui') request.addfinalizer(provision_request.remove_request) assert provision_request.row.reason.text == "Quota Exceeded"
def test_user_quota_diff_groups(request, appliance, provider, setup_provider, new_user, set_parent_tenant_quota, extra_msg, custom_prov_data, approve, prov_data, vm_name, template_name): """prerequisite: Provider should be added steps: 1. Provision VM with more than assigned quota Polarion: assignee: None initialEstimate: None """ with new_user: recursive_update(prov_data, custom_prov_data) logger.info("Successfully updated VM provisioning data") do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name, provisioning_data=prov_data, wait=False, request=None) # nav to requests page to check quota validation request_description = 'Provision from [{}] to [{}{}]'.format(template_name, vm_name, extra_msg) provision_request = appliance.collections.requests.instantiate(request_description) if approve: provision_request.approve_request(method='ui', reason="Approved") provision_request.wait_for_request(method='ui') assert provision_request.row.reason.text == "Quota Exceeded"
def test_k6t_vm_crud(request, appliance, provider, provisioning, custom_prov_data): """ Polarion: assignee: rhcf3_machine initialEstimate: 1/4h casecomponent: Infra """ vm_name = random_vm_name('k6tvm') prov_data = {'catalog': {'vm_name': vm_name}} provider.refresh_provider_relationships() prov_data.update(custom_prov_data) template = provisioning['template'] do_vm_provisioning(appliance, template, provider, vm_name, prov_data, request, wait=False) logger.info('Waiting for cfme provision request for vm %s', vm_name) request_description = 'Provision from [{}] to [{}]'.format( template, vm_name) provision_request = appliance.collections.requests.instantiate( request_description) provision_request.wait_for_request(method='ui', num_sec=300) assert provision_request.is_succeeded(method='ui'), \ ("Provisioning failed with the message {}".format(provision_request.row.last_message.text))
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_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_quota(appliance, provider, custom_prov_data, vm_name, admin_email, entities, template_name, prov_data): """This test case checks quota limit using the automate's predefine method 'quota source' Polarion: assignee: ghubale casecomponent: Quota caseimportance: medium initialEstimate: 1/6h tags: quota """ recursive_update(prov_data, custom_prov_data) do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name, provisioning_data=prov_data, wait=False, request=None) # nav to requests page to check quota validation request_description = 'Provision from [{template}] to [{vm}]'.format( template=template_name, vm=vm_name) provision_request = appliance.collections.requests.instantiate( request_description) provision_request.wait_for_request(method='ui') assert provision_request.row.reason.text == "Quota Exceeded"
def test_tenant_quota_enforce_via_lifecycle_infra( appliance, provider, setup_provider, set_roottenant_quota, extra_msg, custom_prov_data, approve, prov_data, vm_name, template_name): """Test Tenant Quota in UI and SSUI Metadata: test_flag: quota """ prov_data.update(custom_prov_data) prov_data['catalog']['vm_name'] = vm_name do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name, provisioning_data=prov_data, smtp_test=False, wait=False, request=None) # nav to requests page to check quota validation request_description = 'Provision from [{}] to [{}{}]'.format( template_name, vm_name, extra_msg) provision_request = appliance.collections.requests.instantiate( request_description) if approve: provision_request.approve_request(method='ui', reason="Approved") provision_request.wait_for_request(method='ui') assert provision_request.row.reason.text == "Quota Exceeded"
def test_child_tenant_quota_enforce_via_lifecycle_infra(appliance, provider, new_user, set_child_tenant_quota, extra_msg, custom_prov_data, approve, prov_data, vm_name, template_name): """Test child tenant feature via lifecycle method. Polarion: assignee: ghubale casecomponent: Infra caseimportance: medium initialEstimate: 1/6h tags: quota """ with new_user: recursive_update(prov_data, custom_prov_data) do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name, provisioning_data=prov_data, wait=False, request=None) # nav to requests page to check quota validation request_description = 'Provision from [{template}] to [{vm}{msg}]'.format( template=template_name, vm=vm_name, msg=extra_msg) provision_request = appliance.collections.requests.instantiate(request_description) if approve: provision_request.approve_request(method='ui', reason="Approved") provision_request.wait_for_request(method='ui') assert provision_request.row.reason.text == "Quota Exceeded"
def test_provision_from_template(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(template, provider, vm_name, provisioning_data, request, smtp_test, num_sec=900)
def test_child_tenant_quota_enforce_via_lifecycle_infra( appliance, provider, setup_provider, new_user, set_child_tenant_quota, extra_msg, custom_prov_data, approve, prov_data, vm_name, template_name): """Test child tenant feature via lifecycle method. Metadata: test_flag: quota Polarion: assignee: ghubale casecomponent: infra initialEstimate: 1/6h """ with new_user: recursive_update(prov_data, custom_prov_data) do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name, provisioning_data=prov_data, wait=False, request=None) # nav to requests page to check quota validation request_description = 'Provision from [{}] to [{}{}]'.format( template_name, vm_name, extra_msg) provision_request = appliance.collections.requests.instantiate( request_description) if approve: provision_request.approve_request(method='ui', reason="Approved") provision_request.wait_for_request(method='ui') assert provision_request.row.reason.text == "Quota Exceeded"
def test_quota_tagging(appliance, provider, setup_provider, set_entity_quota_tag, custom_prov_data, vm_name, template_name, prov_data): """Tests quota tagging Metadata: test_flag: quota """ recursive_update(prov_data, custom_prov_data) do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name, provisioning_data=prov_data, smtp_test=False, wait=False, request=None) # nav to requests page to check quota validation request_description = 'Provision from [{}] to [{}]'.format( template_name, vm_name) provision_request = appliance.collections.requests.instantiate( request_description) provision_request.wait_for_request(method='ui') assert provision_request.row.reason.text == "Quota Exceeded"
def test_tenant_quota_enforce_via_lifecycle_infra(appliance, provider, set_roottenant_quota, extra_msg, custom_prov_data, approve, prov_data, vm_name, template_name): """Test Tenant Quota in UI and SSUI Polarion: assignee: ghubale casecomponent: Infra caseimportance: high initialEstimate: 1/8h tags: quota """ prov_data.update(custom_prov_data) prov_data['catalog']['vm_name'] = vm_name do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name, provisioning_data=prov_data, wait=False, request=None) # nav to requests page to check quota validation request_description = 'Provision from [{template}] to [{vm}{msg}]'.format( template=template_name, vm=vm_name, msg=extra_msg) provision_request = appliance.collections.requests.instantiate(request_description) if approve: provision_request.approve_request(method='ui', reason="Approved") provision_request.wait_for_request(method='ui') assert provision_request.row.reason.text == "Quota Exceeded"
def test_tenant_quota_enforce_via_lifecycle_infra(appliance, provider, set_roottenant_quota, extra_msg, custom_prov_data, approve, prov_data, vm_name, template_name): """Test Tenant Quota in UI and SSUI Polarion: assignee: ghubale casecomponent: Infra caseimportance: high initialEstimate: 1/8h tags: quota """ prov_data.update(custom_prov_data) prov_data['catalog']['vm_name'] = vm_name do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name, provisioning_data=prov_data, wait=False, request=None) # nav to requests page to check quota validation request_description = 'Provision from [{template}] to [{vm}{msg}]'.format( template=template_name, vm=vm_name, msg=extra_msg) provision_request = appliance.collections.requests.instantiate( request_description) if approve: provision_request.approve_request(method='ui', reason="Approved") provision_request.wait_for_request(method='ui') assert provision_request.row.reason.text == "Quota Exceeded"
def test_provision_from_template(provider_init, provider_key, provider_crud, provider_type, provider_mgmt, provisioning, vm_name, smtp_test, request): """ Tests provisioning from a template Metadata: test_flag: provision suite: infra_provisioning """ # generate_tests makes sure these have values template, host, datastore = map(provisioning.get, ('template', 'host', 'datastore')) request.addfinalizer(lambda: cleanup_vm(vm_name, provider_key, provider_mgmt)) provisioning_data = { 'vm_name': vm_name, 'host_name': {'name': [host]}, 'datastore_name': {'name': [datastore]} } # 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_crud, vm_name, provisioning_data, request, provider_mgmt, provider_key, smtp_test, num_sec=900)
def test_user_quota_diff_groups(appliance, provider, new_user, set_parent_tenant_quota, extra_msg, custom_prov_data, approve, prov_data, vm_name, template_name): """ Polarion: assignee: ghubale initialEstimate: 1/4h casecomponent: Quota caseimportance: high tags: quota """ with new_user: recursive_update(prov_data, custom_prov_data) logger.info("Successfully updated VM provisioning data") do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name, provisioning_data=prov_data, wait=False, request=None) # nav to requests page to check quota validation request_description = 'Provision from [{template}] to [{vm}{msg}]'.format( template=template_name, vm=vm_name, msg=extra_msg) provision_request = appliance.collections.requests.instantiate( request_description) if approve: provision_request.approve_request(method='ui', reason="Approved") provision_request.wait_for_request(method='ui') assert provision_request.row.reason.text == "Quota Exceeded"
def test_provision_cloud_init(setup_provider, provider, setup_ci_template, vm_name, smtp_test, request, provisioning): """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 test_quota_exceed_mail_with_more_info_link(configure_mail, appliance, provider, set_roottenant_quota, custom_prov_data, prov_data, extra_msg, vm_name, template_name): """ Bugzilla: 1579031 1759123 Polarion: assignee: ghubale initialEstimate: 1/12h caseimportance: high caseposneg: positive testtype: functional startsin: 5.9 casecomponent: Infra tags: quota setup: 1. Copy instance ManageIQ/Configuration/Email/Default to custom domain 2. Enter values for fields: approver, default_recipient, from and signature testSteps: 1. Provide valid mail address while provisioning Vm to exceed quota expectedResults: 1. Quota exceed mail should be sent """ approver, default_recipient, from_user = configure_mail mail_to = fauxfactory.gen_email() prov_data.update(custom_prov_data) prov_data['catalog']['vm_name'] = vm_name with LogValidator( "/var/www/miq/vmdb/log/automation.log", matched_patterns= [ f'"to"=>"{default_recipient}", "from"=>"{from_user}".*.Virtual Machine Request from ' f'{mail_to} was Denied."', f'"to"=>"{mail_to}", "from"=>"{from_user}".*.Your Virtual Machine Request was Approved,' f' pending Quota Validation.".*' ], ).waiting(timeout=120): do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name, provisioning_data=prov_data, wait=False, request=None, email=mail_to) # nav to requests page to check quota validation request_description = f'Provision from [{template_name}] to [{vm_name}{extra_msg}]' provision_request = appliance.collections.requests.instantiate( request_description) provision_request.wait_for_request(method='ui') assert provision_request.row.reason.text == "Quota Exceeded"
def test_pxe_provision_from_template(appliance, 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: appliance.collections.infra_vms.instantiate( vm_name, provider).cleanup_on_provider()) provisioning_data = { 'catalog': { 'vm_name': vm_name, 'provision_type': 'PXE', 'pxe_server': pxe_server, 'pxe_image': { 'name': pxe_image } }, 'environment': { 'host_name': { 'name': host }, 'datastore_name': { 'name': datastore } }, 'customize': { 'custom_template': { 'name': pxe_kickstart }, 'root_password': pxe_root_password }, 'network': { 'vlan': partial_match(pxe_vlan) } } do_vm_provisioning(appliance, pxe_template, provider, vm_name, provisioning_data, request, smtp_test, num_sec=3600)
def test_iso_provision_from_template(appliance, provider, vm_name, datastore_init, request): """Tests ISO provisioning Metadata: test_flag: iso, provision suite: infra_provisioning Polarion: assignee: jhenner caseimportance: high casecomponent: Provisioning initialEstimate: 1/4h """ # generate_tests makes sure these have values (iso_template, host, datastore, iso_file, iso_kickstart, iso_root_password, iso_image_type, vlan, addr_mode) = tuple(map(provider.data['provisioning'].get, ('pxe_template', 'host', 'datastore', 'iso_file', 'iso_kickstart', 'iso_root_password', 'iso_image_type', 'vlan', 'iso_address_mode'))) request.addfinalizer(lambda: appliance.collections.infra_vms.instantiate(vm_name, provider) .cleanup_on_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, 'address_mode': addr_mode}, 'network': { 'vlan': partial_match(vlan)}, 'schedule': { 'power_on': False}} do_vm_provisioning(appliance, iso_template, provider, vm_name, provisioning_data, request, num_sec=1800)
def test_provision_from_template(rbac_role, configure_ldap_auth_mode, setup_provider, provider, vm_name, smtp_test, request, provisioning): """ 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 """ # generate_tests makes sure these have values template, host, datastore = map(provisioning.get, ('template', 'host', 'datastore')) request.addfinalizer(lambda: cleanup_vm(vm_name, provider)) provisioning_data = { 'vm_name': vm_name, 'host_name': { 'name': [host] }, 'datastore_name': { 'name': [datastore] } } # 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, num_sec=900)
def test_quota_tagging(appliance, provider, setup_provider, set_entity_quota_tag, custom_prov_data, vm_name, template_name, prov_data): prov_data.update(custom_prov_data) prov_data['catalog']['vm_name'] = vm_name do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name, provisioning_data=prov_data, smtp_test=False, wait=False, request=None) # nav to requests page to check quota validation request_description = 'Provision from [{}] to [{}]'.format(template_name, vm_name) provision_request = appliance.collections.requests.instantiate(request_description) provision_request.wait_for_request(method='ui') assert provision_request.row.reason.text == "Quota Exceeded"
def test_quota(appliance, provider, setup_provider, custom_prov_data, vm_name, admin_email, entities, template_name, prov_data): """This test case checks quota limit using the automate's predefine method 'quota source'""" recursive_update(prov_data, custom_prov_data) do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name, provisioning_data=prov_data, smtp_test=False, wait=False, request=None) # nav to requests page to check quota validation request_description = 'Provision from [{}] to [{}]'.format(template_name, vm_name) provision_request = appliance.collections.requests.instantiate(request_description) provision_request.wait_for_request(method='ui') assert provision_request.row.reason.text == "Quota Exceeded"
def test_quota_tagging_infra_via_lifecycle(request, appliance, provider, setup_provider, set_entity_quota_tag, custom_prov_data, vm_name, template_name, prov_data): recursive_update(prov_data, custom_prov_data) do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name, provisioning_data=prov_data, wait=False, request=None) # nav to requests page to check quota validation request_description = 'Provision from [{}] to [{}]'.format(template_name, vm_name) provision_request = appliance.collections.requests.instantiate(request_description) provision_request.wait_for_request(method='ui') request.addfinalizer(provision_request.remove_request) assert provision_request.row.reason.text == "Quota Exceeded"
def test_quota_tagging_infra_via_lifecycle(request, appliance, provider, setup_provider, set_entity_quota_tag, custom_prov_data, vm_name, template_name, prov_data): recursive_update(prov_data, custom_prov_data) do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name, provisioning_data=prov_data, smtp_test=False, wait=False, request=None) # nav to requests page to check quota validation request_description = 'Provision from [{}] to [{}]'.format(template_name, vm_name) provision_request = appliance.collections.requests.instantiate(request_description) provision_request.wait_for_request(method='ui') request.addfinalizer(provision_request.remove_request) assert provision_request.row.reason.text == "Quota Exceeded"
def _provisioner(appliance, template, provisioning_data, vm_name, delayed=None): do_vm_provisioning(appliance, template_name=template, provider=provider, vm_name=vm_name, provisioning_data=provisioning_data, request=None, smtp_test=None, wait=False)
def test_pxe_provision_from_template(appliance, provider, vm_name, setup_provider, request, setup_pxe_servers_vm_prov): """Tests provisioning via PXE Metadata: test_flag: pxe, provision suite: infra_provisioning Polarion: assignee: jhenner casecomponent: Provisioning initialEstimate: 1/6h testtype: integration upstream: yes """ # 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: appliance.collections.infra_vms.instantiate(vm_name, provider) .cleanup_on_provider()) provisioning_data = { 'catalog': { 'vm_name': vm_name, 'provision_type': 'PXE', 'pxe_server': pxe_server, 'pxe_image': {'name': pxe_image}}, 'environment': { 'host_name': {'name': host}, 'datastore_name': {'name': datastore}}, 'customize': { 'custom_template': {'name': pxe_kickstart}, 'root_password': pxe_root_password}, 'network': { 'vlan': partial_match(pxe_vlan)}} do_vm_provisioning(appliance, pxe_template, provider, vm_name, provisioning_data, request, num_sec=3600)
def test_iso_provision_from_template( provider_key, provider_crud, provider_type, provider_mgmt, provisioning, vm_name, smtp_test, provider_init, request ): """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_key, provider_mgmt)) 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_crud, vm_name, provisioning_data, request, provider_mgmt, provider_key, smtp_test, num_sec=1500, )
def test_tenant_quota_enforce_via_lifecycle_infra(appliance, provider, setup_provider, set_roottenant_quota, extra_msg, custom_prov_data, approve, prov_data, vm_name, template_name): """Test Tenant Quota in UI and SSUI""" prov_data.update(custom_prov_data) prov_data['catalog']['vm_name'] = vm_name do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name, provisioning_data=prov_data, smtp_test=False, wait=False, request=None) # nav to requests page to check quota validation request_description = 'Provision from [{}] to [{}{}]'.format(template_name, vm_name, extra_msg) provision_request = appliance.collections.requests.instantiate(request_description) if approve: provision_request.approve_request(method='ui', reason="Approved") provision_request.wait_for_request(method='ui') assert provision_request.row.reason.text == "Quota Exceeded"
def test_provision_cloud_init(provider_init, provider_key, provider_crud, provider_type, setup_ci_template, provider_mgmt, 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_crud.get_mgmt_system() request.addfinalizer(lambda: cleanup_vm(vm_name, provider_key, provider_mgmt)) 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_crud, vm_name, provisioning_data, request, provider_mgmt, provider_key, 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 test_k6t_vm_crud(request, appliance, provider, provisioning, custom_prov_data): """ Polarion: assignee: rhcf3_machine initialEstimate: 1/4h casecomponent: Infra """ vm_name = random_vm_name('k6tvm') prov_data = {'catalog': {'vm_name': vm_name}} provider.refresh_provider_relationships() prov_data.update(custom_prov_data) template = provisioning['template'] do_vm_provisioning(appliance, template, provider, vm_name, prov_data, request, wait=False) logger.info('Waiting for cfme provision request for vm %s', vm_name) request_description = 'Provision from [{}] to [{}]'.format(template, vm_name) provision_request = appliance.collections.requests.instantiate(request_description) provision_request.wait_for_request(method='ui', num_sec=300) assert provision_request.is_succeeded(method='ui'), \ ("Provisioning failed with the message {}".format(provision_request.row.last_message.text))
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_provision_from_template(rbac_role, 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 = { '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 } # 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, num_sec=900)
def test_provision_from_template(rbac_role, configure_ldap_auth_mode, setup_provider, provider, provisioning, vm_name, smtp_test, request): """ 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 """ # generate_tests makes sure these have values template, host, datastore = map(provisioning.get, ('template', 'host', 'datastore')) request.addfinalizer(lambda: cleanup_vm(vm_name, provider)) provisioning_data = { 'vm_name': vm_name, 'host_name': {'name': [host]}, 'datastore_name': {'name': [datastore]} } # 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, num_sec=900)
def test_pxe_provision_from_template(appliance, 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 = { 'catalog': { 'vm_name': vm_name, 'provision_type': 'PXE', 'pxe_server': pxe_server, 'pxe_image': {'name': pxe_image}}, 'environment': { 'host_name': {'name': host}, 'datastore_name': {'name': datastore}}, 'customize': { 'custom_template': {'name': pxe_kickstart}, 'root_password': pxe_root_password}, 'network': { 'vlan': pxe_vlan}} do_vm_provisioning(appliance, pxe_template, provider, vm_name, provisioning_data, request, smtp_test, num_sec=3600)
def test_provision_cloud_init(appliance, setup_provider, provider, setup_ci_template, vm_name, smtp_test, request, provisioning): """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') or provisioning['image']['name'] host, datastore, vlan = map(provisioning.get, ('host', 'datastore', 'vlan')) mgmt_system = provider.get_mgmt_system() request.addfinalizer(lambda: cleanup_vm(vm_name, provider)) provisioning_data = { 'catalog': { 'provision_type': 'Native Clone', 'vm_name': vm_name}, 'environment': { 'host_name': {'name': host}, 'datastore_name': {'name': datastore}}, 'network': { 'vlan': vlan}, 'customize': { 'custom_template': {'name': [provisioning['ci-template']]}} } do_vm_provisioning(appliance, 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 with ssh.SSHClient(hostname=connect_ip, username=provisioning['ci-username'], password=provisioning['ci-pass']) as ssh_client: wait_for(ssh_client.uptime, num_sec=200, handle_exception=True)
def test_iso_provision_from_template(appliance, provider, vm_name, datastore_init, request): """Tests ISO provisioning Metadata: test_flag: iso, provision suite: infra_provisioning Polarion: assignee: jhenner caseimportance: high casecomponent: Provisioning initialEstimate: 1/4h """ # generate_tests makes sure these have values iso_template, host, datastore, iso_file, iso_kickstart,\ iso_root_password, iso_image_type, vlan, addr_mode = map(provider.data['provisioning'].get, ('pxe_template', 'host', 'datastore', 'iso_file', 'iso_kickstart', 'iso_root_password', 'iso_image_type', 'vlan', 'iso_address_mode')) request.addfinalizer(lambda: appliance.collections.infra_vms.instantiate(vm_name, provider) .cleanup_on_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, 'address_mode': addr_mode}, 'network': { 'vlan': partial_match(vlan)}, 'schedule': { 'power_on': False}} do_vm_provisioning(appliance, iso_template, provider, vm_name, provisioning_data, request, num_sec=1800)
def test_quota(appliance, provider, custom_prov_data, vm_name, admin_email, entities, template_name, prov_data): """This test case checks quota limit using the automate's predefine method 'quota source' Polarion: assignee: ghubale casecomponent: Quota caseimportance: medium initialEstimate: 1/6h tags: quota """ recursive_update(prov_data, custom_prov_data) do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name, provisioning_data=prov_data, wait=False, request=None) # nav to requests page to check quota validation request_description = 'Provision from [{template}] to [{vm}]'.format(template=template_name, vm=vm_name) provision_request = appliance.collections.requests.instantiate(request_description) provision_request.wait_for_request(method='ui') assert provision_request.row.reason.text == "Quota Exceeded"
def test_provision_from_template( rbac_role, configure_ldap_auth_mode, setup_provider, provider, vm_name, smtp_test, request, provisioning ): """ 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 """ # generate_tests makes sure these have values template, host, datastore = map(provisioning.get, ("template", "host", "datastore")) request.addfinalizer(lambda: cleanup_vm(vm_name, provider)) provisioning_data = {"vm_name": vm_name, "host_name": {"name": [host]}, "datastore_name": {"name": [datastore]}} # 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, num_sec=900)
def test_quota_tagging_infra_via_lifecycle(request, appliance, provider, set_entity_quota_tag, custom_prov_data, vm_name, template_name, prov_data): """ Polarion: assignee: ghubale casecomponent: Quota caseimportance: medium initialEstimate: 1/6h tags: quota """ recursive_update(prov_data, custom_prov_data) do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name, provisioning_data=prov_data, wait=False, request=None) # nav to requests page to check quota validation request_description = 'Provision from [{template}] to [{vm}]'.format(template=template_name, vm=vm_name) provision_request = appliance.collections.requests.instantiate(request_description) provision_request.wait_for_request(method='ui') request.addfinalizer(provision_request.remove_request) assert provision_request.row.reason.text == "Quota Exceeded"
def test_child_tenant_quota_enforce_via_lifecycle_infra(appliance, provider, setup_provider, new_user, set_child_tenant_quota, extra_msg, custom_prov_data, approve, prov_data, vm_name, template_name): """Test child tenant feature via lifecycle method. Metadata: test_flag: quota """ with new_user: recursive_update(prov_data, custom_prov_data) do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name, provisioning_data=prov_data, smtp_test=False, wait=False, request=None) # nav to requests page to check quota validation request_description = 'Provision from [{}] to [{}{}]'.format(template_name, vm_name, extra_msg) provision_request = appliance.collections.requests.instantiate(request_description) if approve: provision_request.approve_request(method='ui', reason="Approved") provision_request.wait_for_request(method='ui') assert provision_request.row.reason.text == "Quota Exceeded"
def test_provision_approval( setup_provider, provider, provisioning, vm_name, smtp_test, request, edit): """ 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)} check = "vm provisioned successfully" 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]) check = "request complete" 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 "{}" to appear on provider {}'.format( ", ".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.last_message.text) == check # 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 _ssa_single_vm(): template_name = vm_analysis_provisioning_data['image'] vm_name = 'test-ssa-{}-{}'.format(fauxfactory.gen_alphanumeric(), analysis_type) collection = provider.appliance.provider_based_collection(provider) vm = collection.instantiate(vm_name, provider, template_name=vm_analysis_provisioning_data.image) provision_data = vm_analysis_provisioning_data.copy() del provision_data['image'] if "test_ssa_compliance" in request._pyfuncitem.name: provisioning_data = {"catalog": {'vm_name': vm_name}, "environment": {'automatic_placement': True}} do_vm_provisioning(vm_name=vm_name, appliance=appliance, provider=provider, provisioning_data=provisioning_data, template_name=template_name, request=request, smtp_test=False, num_sec=2500) else: deploy_template(vm.provider.key, vm_name, template_name, timeout=2500) vm.wait_to_appear(timeout=900, load_details=False) request.addfinalizer(lambda: vm.delete_from_provider()) 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=credentials[vm_analysis_provisioning_data.credentials]['username'], password=credentials[vm_analysis_provisioning_data.credentials]['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 = InfraVm.CfmeRelationship(vm) cfme_rel.set_relationship(appliance.server.name, appliance.server_id()) # Close the SSH client if we have one request.addfinalizer(lambda: vm.ssh.close() if getattr(vm, 'ssh', None) else None) return vm
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: [VM.factory(name, provider).cleanup_on_provider() for name in vm_names]) provisioning_data = { 'catalog': { 'vm_name': vm_name, 'num_vms': '2' }, 'environment': { 'host_name': {'name': host}, 'datastore_name': {'name': datastore} }, 'network': { 'vlan': partial_match(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())) == 1, 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())) == 1, num_sec=90, delay=5) smtp_test.clear_database() 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: VM.factory(new_vm_name, provider).cleanup_on_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: [VM.factory(name, provider).cleanup_on_provider() for name 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())) == 1, num_sec=120, delay=5) smtp_test.clear_database() # 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') msg = "Provisioning failed with the message {}".format(provision_request.row.last_message.text) assert provision_request.is_succeeded(method='ui'), msg # 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 _ssa_single_vm(): template_name = vm_analysis_provisioning_data['image'] vm_name = f'test-ssa-{fauxfactory.gen_alphanumeric()}-{analysis_type}' collection = provider.appliance.provider_based_collection(provider) vm = collection.instantiate( vm_name, provider, template_name=vm_analysis_provisioning_data.image) provision_data = vm_analysis_provisioning_data.copy() del provision_data['image'] if "test_ssa_compliance" in request._pyfuncitem.name or provider.one_of( RHEVMProvider): provisioning_data = { "catalog": { 'vm_name': vm_name }, "environment": { 'automatic_placement': True } } if provider.one_of(RHEVMProvider): provisioning_data.update({ "network": { 'vlan': partial_match(provision_data['vlan']) } }) do_vm_provisioning(vm_name=vm_name, appliance=appliance, provider=provider, provisioning_data=provisioning_data, template_name=template_name, request=request, num_sec=2500) else: deploy_template(vm.provider.key, vm_name, template_name, timeout=2500) vm.wait_to_appear(timeout=900, load_details=False) request.addfinalizer(lambda: vm.cleanup_on_provider()) if provider.one_of(OpenStackProvider): public_net = provider.data['public_network'] vm.mgmt.assign_floating_ip(public_net) logger.info("VM %s provisioned, waiting for IP address to be assigned", vm_name) vm.mgmt.ensure_state(VmState.RUNNING) try: connect_ip, _ = wait_for(find_pingable, func_args=[vm.mgmt], timeout="10m", delay=5, fail_condition=None) except TimedOutError: pytest.fail('Timed out waiting for pingable address on SSA VM') # 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=credentials[ vm_analysis_provisioning_data.credentials]['username'], password=credentials[ vm_analysis_provisioning_data.credentials]['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 = InfraVm.CfmeRelationship(vm) cfme_rel.set_relationship(appliance.server.name, appliance.server_id()) # Close the SSH client if we have one request.addfinalizer(lambda: vm.ssh.close() if getattr(vm, 'ssh', None) else None) return vm
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: [ appliance.collections.infra_vms.instantiate(name, provider). delete_from_provider() for name in vm_names ]) provisioning_data = { 'catalog': { 'vm_name': vm_name, 'num_vms': '2' }, 'environment': { 'host_name': { 'name': host }, 'datastore_name': { 'name': datastore } }, 'network': { 'vlan': partial_match(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())) == 1, 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())) == 1, num_sec=90, delay=5) smtp_test.clear_database() 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: appliance.collections.infra_vms.instantiate( new_vm_name, provider).delete_from_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: [ appliance.collections.infra_vms.instantiate(name, provider). delete_from_provider() for name 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())) == 1, num_sec=120, delay=5) smtp_test.clear_database() # 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') msg = "Provisioning failed with the message {}".format( provision_request.row.last_message.text) assert provision_request.is_succeeded(method='ui'), msg # 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 test_user_requester_for_lifecycle_provision(request, appliance, provider, setup_provider, new_users, generic_catalog_item, infra_validate_request, service_validate_request, provisioning): """ Polarion: assignee: ghubale casecomponent: Automate caseimportance: high initialEstimate: 1/6h tags: automate Bugzilla: 1671563 1720273 1728706 """ script = """ user = $evm.root['user'] $evm.log(:info, "This is the user: #{user.userid}") $evm.log("info", "Listing Root Object Attributes:") $evm.root.attributes.sort.each { |k, v| $evm.log("info", "\t#{k}: #{v}") } $evm.log("info", "===========================================") """ infra_validate_request.update(updates={"script": script}) service_validate_request.update(updates={"script": script}) with new_users[0]: # Log in with first user and order service catalog result = LogValidator( "/var/www/miq/vmdb/log/automation.log", matched_patterns=[ ".*This is the user: {name}.*".format( name=new_users[0].credential.principal) ], ) result.start_monitoring() service_catalogs = ServiceCatalogs( appliance, catalog=generic_catalog_item.catalog, name=generic_catalog_item.name) provision_request = service_catalogs.order() provision_request.wait_for_request() assert result.validate(wait="60s") with new_users[1]: # Log in with second user and provision instance via lifecycle result = LogValidator( "/var/www/miq/vmdb/log/automation.log", matched_patterns=[ ".*This is the user: {name}.*".format( name=new_users[1].credential.principal) ], ) result.start_monitoring() prov_data = { "catalog": { 'vm_name': random_vm_name(context='provision') }, "environment": { 'automatic_placement': True }, } do_vm_provisioning(appliance, template_name=provisioning["template"], provider=provider, vm_name=prov_data['catalog']['vm_name'], provisioning_data=prov_data, wait=False, request=None) request_description = 'Provision from [{template}] to [{vm}{msg}]'.format( template=provisioning["template"], vm=prov_data['catalog']['vm_name'], msg='') provision_request = appliance.collections.requests.instantiate( request_description) provision_request.wait_for_request(method='ui') request.addfinalizer(provision_request.remove_request) assert result.validate(wait="60s")
def _ssa_single_vm(): template_name = vm_analysis_provisioning_data['image'] vm_name = 'test-ssa-{}-{}'.format(fauxfactory.gen_alphanumeric(), analysis_type) collection = provider.appliance.provider_based_collection(provider) vm = collection.instantiate(vm_name, provider, template_name=vm_analysis_provisioning_data.image) provision_data = vm_analysis_provisioning_data.copy() del provision_data['image'] if "test_ssa_compliance" in request._pyfuncitem.name or provider.one_of(RHEVMProvider): provisioning_data = {"catalog": {'vm_name': vm_name}, "environment": {'automatic_placement': True}} if provider.one_of(RHEVMProvider): provisioning_data.update( {"network": {'vlan': partial_match(provision_data['vlan'])}} ) do_vm_provisioning(vm_name=vm_name, appliance=appliance, provider=provider, provisioning_data=provisioning_data, template_name=template_name, request=request, num_sec=2500) else: deploy_template(vm.provider.key, vm_name, template_name, timeout=2500) vm.wait_to_appear(timeout=900, load_details=False) request.addfinalizer(lambda: vm.cleanup_on_provider()) if provider.one_of(OpenStackProvider): public_net = provider.data['public_network'] vm.mgmt.assign_floating_ip(public_net) logger.info("VM %s provisioned, waiting for IP address to be assigned", vm_name) vm.mgmt.ensure_state(VmState.RUNNING) @wait_for_decorator(timeout="10m", delay=5) def get_ip_address(): ip = vm.mgmt.ip logger.info("Fetched IP for %s: %s", vm_name, ip) return ip is not None connect_ip = vm.mgmt.ip 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=credentials[vm_analysis_provisioning_data.credentials]['username'], password=credentials[vm_analysis_provisioning_data.credentials]['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 = InfraVm.CfmeRelationship(vm) cfme_rel.set_relationship(appliance.server.name, appliance.server_id()) # Close the SSH client if we have one request.addfinalizer(lambda: vm.ssh.close() if getattr(vm, 'ssh', None) else None) return vm