def test_charge_report_filter_tag(setup_first_provider, request): """Tests creation of chargeback report that is filtered by tag """ report = CustomReport( menu_name=generate_random_string(), title=generate_random_string(), base_report_on="Chargebacks", report_fields=[ "CPU Used", "CPU Used Cost", "Memory Used", "Memory Used Cost", "Owner", "vCPUs Allocated Cost", "Total Cost", ], filter_show_costs="My Company Tag", filter_tag_cat="Location", filter_tag_value="Chicago", ) report.create() def cleanup_report(report): return lambda: _cleanup_report(report) request.addfinalizer(cleanup_report(report)) flash.assert_message_match('Report "{}" was added'.format(report.menu_name)) report.queue(wait_for_finish=True)
def publish_to_template(self, template_name, email=None, first_name=None, last_name=None): self.load_details() lcl_btn("Publish this VM to a Template") first_name = first_name or generate_random_string() last_name = last_name or generate_random_string() email = email or "{}@{}.test".format(first_name, last_name) try: prov_data = cfme_data["management_systems"][self.provider_crud.key]["provisioning"] except (KeyError, IndexError): raise ValueError("You have to specify the correct options in cfme_data.yaml") provisioning_data = { "first_name": first_name, "last_name": last_name, "email": email, "vm_name": template_name, "host_name": {"name": prov_data.get("host")}, "datastore_name": {"name": prov_data.get("datastore")}, } from cfme.provisioning import provisioning_form fill(provisioning_form, provisioning_data, action=provisioning_form.submit_button) cells = {'Description': 'Publish from [%s] to [%s]' % (self.name, template_name)} row, __ = wait_for( requests.wait_for_request, [cells], fail_func=requests.reload, num_sec=900, delay=20) return Template(template_name, self.provider_crud)
def test_charge_report_filter_owner(setup_first_provider, request): """Tests creation of chargeback report that is filtered by owner """ report = CustomReport( menu_name=generate_random_string(), title=generate_random_string(), base_report_on="Chargebacks", report_fields=[ "Network I/O Used", "Network I/O Used Cost", "Storage Used", "Storage Used Cost", "Disk I/O Used", "Disk I/O Used Cost", "Owner", "Total Cost", ], filter_show_costs="Owner", filter_owner="Administrator", ) report.create() def cleanup_report(report): return lambda: _cleanup_report(report) request.addfinalizer(cleanup_report(report)) flash.assert_message_match('Report "{}" was added'.format(report.menu_name)) report.queue(wait_for_finish=True)
def fleecing_vm( request, compliance_vm, vm_analysis, provider_mgmt, provider_key, provider_crud, analysis_profile): logger.info("Provisioning an appliance for fleecing on {}".format(provider_key)) # TODO: When we get something smaller, use it! appliance = provision_appliance( vm_name_prefix=PREFIX + "for_fleece_", version=str(version.current_version()), provider_name=provider_key) request.addfinalizer(lambda: diaper(appliance.destroy)) logger.info("Appliance {} provisioned".format(appliance.vm_name)) vm = Vm(appliance.vm_name, provider_crud) provider_crud.refresh_provider_relationships() vm.wait_to_appear() # Assign the analysis profile action = Action( "Assign analysis profile {}".format(analysis_profile.name), "Assign Profile to Analysis Task", dict(analysis_profile=analysis_profile.name)) action.create() request.addfinalizer(action.delete) policy = VMControlPolicy("Analysis profile policy {}".format(generate_random_string())) policy.create() request.addfinalizer(policy.delete) policy.assign_actions_to_event("VM Analysis Start", action) analysis_pp = PolicyProfile( "Analysis profile PP {}".format(generate_random_string()), policies=[policy]) analysis_pp.create() request.addfinalizer(analysis_pp.delete) vm.assign_policy_profiles(analysis_pp.description) request.addfinalizer(lambda: vm.unassign_policy_profiles(analysis_pp.description)) return vm
def test_check_package_presence(request, fleecing_vm, ssh_client, vm_analysis, analysis_profile): """This test checks compliance by presence of a certain cfme-appliance package which is expected to be present on an appliance.""" # TODO: If we step out from provisioning a full appliance for fleecing, this might need revisit condition = VMCondition( "Compliance testing condition {}".format(generate_random_string(size=8)), expression=("fill_find(field=VM and Instance.Guest Applications : Name, " "skey=STARTS WITH, value=cfme-appliance, check=Check Count, ckey= = , cvalue=1)") ) request.addfinalizer(lambda: diaper(condition.delete)) policy = VMCompliancePolicy("Compliance {}".format(generate_random_string(size=8))) request.addfinalizer(lambda: diaper(policy.delete)) policy.create() policy.assign_conditions(condition) profile = PolicyProfile( "Compliance PP {}".format(generate_random_string(size=8)), policies=[policy] ) request.addfinalizer(lambda: diaper(profile.delete)) profile.create() fleecing_vm.assign_policy_profiles(profile.description) request.addfinalizer(lambda: fleecing_vm.unassign_policy_profiles(profile.description)) with update(analysis_profile): analysis_profile.categories = [ "check_services", "check_accounts", "check_software", "check_vmconfig", "check_system"] do_scan(fleecing_vm) assert fleecing_vm.check_compliance_and_wait()
def test_password_max_character_validation(): password = generate_random_string(size=51) cred = Credential( principal=generate_random_string(size=5), secret=password, verify_secret=password) provider.discover(cred)
def test_service_circular_reference(catalog_item): bundle_name = "first_" + generate_random_string() catalog_bundle = CatalogBundle(name=bundle_name, description="catalog_bundle", display_in=True, catalog=catalog_item.catalog, dialog=catalog_item.dialog, cat_item=catalog_item.name) catalog_bundle.create() sec_bundle_name = "sec_" + generate_random_string() sec_catalog_bundle = CatalogBundle(name=sec_bundle_name, description="catalog_bundle", display_in=True, catalog=catalog_item.catalog, dialog=catalog_item.dialog, cat_item=bundle_name) sec_catalog_bundle.create() with error.expected( "Error during 'Resource Add': Adding resource <%s> to Service <%s> " "will create a circular reference" % (sec_bundle_name, bundle_name)): catalog_bundle.update({ 'description': "edit_desc", 'cat_item': sec_catalog_bundle.name })
def category(): cg = Category(name=generate_lowercase_random_string(size=8), description=generate_random_string(size=32), display_name=generate_random_string(size=32)) cg.create() yield cg cg.delete()
def category(): cg = Category(name=generate_lowercase_random_string(size=8), description=generate_random_string(size=32), display_name=generate_random_string(size=32)) cg.create() yield cg cg.delete()
def test_ec2_catalog_item(provider_init, provider_key, provider_mgmt, provider_crud, provider_type, provisioning, dialog, catalog, request): # tries to delete the VM that gets created here vm_name = 'test_ec2_servicecatalog-%s' % generate_random_string() image = provisioning['image']['name'] item_name = "ec2_" + generate_random_string() ec2_catalog_item = ec2.Instance( item_type="Amazon", name=item_name, description="my catalog", display_in=True, catalog=catalog.name, dialog=dialog, catalog_name=image, vm_name=vm_name, instance_type=provisioning['instance_type'], availability_zone=provisioning['availability_zone'], security_groups=[provisioning['security_group']], provider_mgmt=provider_mgmt, provider=provider_crud.name, guest_keypair="shared") ec2_catalog_item.create() service_catalogs = ServiceCatalogs("service_name") service_catalogs.order(catalog.name, ec2_catalog_item) flash.assert_no_errors() logger.info('Waiting for cfme provision request for service %s' % item_name) row_description = 'Provisioning [%s] for Service [%s]' % (item_name, item_name) cells = {'Description': row_description} request.addfinalizer(lambda: cleanup_vm(vm_name, provider_key, provider_mgmt)) row, __ = wait_for(requests.wait_for_request, [cells], fail_func=requests.reload, num_sec=600, delay=20) assert row.last_message.text == 'Request complete'
def report_vms(setup_first_provider): report = CustomReport( menu_name=generate_random_string(), title=generate_random_string(), base_report_on="Virtual Machines", report_fields=[ version.pick({ version.LOWEST: "Provider : Name", "5.3": "Cloud/Infrastructure Provider : Name", }), "Cluster : Name", "Datastore : Name", "Hardware : Number of CPUs", "Hardware : RAM", "Host : Name", "Name", ] ) report.create() report.queue(wait_for_finish=True) yield pick( filter( lambda i: len(i[ version.pick({ version.LOWEST: "Provider : Name", "5.3": "Cloud/Infrastructure Provider Name", }) ].strip()) > 0, list(report.get_saved_reports()[0].data.rows)), 2) report.delete()
def test_ip_max_character_validation(): """Test to validate max character for ip address field""" prov = provider.VMwareProvider(name=generate_random_string(size=5), hostname=generate_random_string(size=5), ip_address='10.10.10.12') prov.create() prov.delete(cancel=False)
def test_tag_crud(category): tag = Tag(name=generate_lowercase_random_string(size=8), display_name=generate_random_string(size=32), category=category) tag.create() with update(tag): tag.display_name = generate_random_string(size=32) tag.delete(cancel=False)
def test_host_analysis_profile_crud(): """CRUD for Host analysis profiles.""" p = HostAnalysisProfile( generate_random_string(), generate_random_string(), files=["asdf", "dfg"]) p.create() with update(p): p.files = ["qwer"] p.delete()
def test_category_crud(): cg = Category(name=generate_lowercase_random_string(size=8), description=generate_random_string(size=32), display_name=generate_random_string(size=32)) cg.create() with update(cg): cg.description = generate_random_string(size=32) cg.delete(cancel=False)
def test_ip_max_character_validation(): """Test to validate max character for ip address field""" prov = provider.VMwareProvider( name=generate_random_string(size=5), hostname=generate_random_string(size=5), ip_address='10.10.10.12') prov.create() prov.delete(cancel=False)
def test_ip_required_validation(): """Test to validate the ip address while adding a provider""" prov = provider.VMwareProvider(name=generate_random_string(size=5), hostname=generate_random_string(size=5), ip_address=None) with error.expected("IP Address can't be blank"): prov.create()
def test_button_group_crud(request): buttongroup = ButtonGroup( text=generate_random_string(), hover="btn_hvr", type=ButtonGroup.SERVICE) request.addfinalizer(buttongroup.delete_if_exists) buttongroup.create() with update(buttongroup): buttongroup.hover = "edit_desc_{}".format(generate_random_string()) buttongroup.delete()
def test_password_mismatch_validation(): cred = Credential( principal=generate_random_string(size=5), secret=generate_random_string(size=5), verify_secret=generate_random_string(size=7)) provider.discover(cred) flash.assert_message_match('Password/Verify Password do not match')
def test_api_port_max_character_validation(): """Test to validate max character for api port field""" prov = provider.RHEVMProvider(name=generate_random_string(size=5), hostname=generate_random_string(size=5), ip_address='10.10.10.13', api_port=generate_random_string(size=15)) prov.create() prov.delete(cancel=False)
def _make_class(): name = generate_random_string(8) description = generate_random_string(32) cls = Class(name=name, description=description, namespace=_make_namespace()) cls.create() return cls
def a_namespace_with_path(domain=None): name = generate_random_string(8) if not domain: domain = make_domain() n = Namespace.make_path('Factory', 'StateMachines', name, domain=domain) n.description = generate_random_string(32) return n
def _create_dashboard(widgets): return Dashboard( generate_random_string(), "EvmGroup-super_administrator", generate_random_string(), locked=False, widgets=widgets )
def _generate_vm_name(): if version is not None: version_digits = ''.join( [letter for letter in version if letter.isdigit()]) return '{}_{}_{}'.format(vm_name_prefix, version_digits, generate_random_string()) else: return '{}_{}'.format(vm_name_prefix, generate_random_string())
def test_user_password_required_error_validation(): user = ac.User( name='user' + random.generate_random_string(), credential=Credential(principal='uid' + random.generate_random_string(), secret=None), email='*****@*****.**', group=group_user) with error.expected("Password_digest can't be blank"): user.create()
def test_ip_required_validation(): """Test to validate the ip address while adding a provider""" prov = provider.VMwareProvider( name=generate_random_string(size=5), hostname=generate_random_string(size=5), ip_address=None) with error.expected("IP Address can't be blank"): prov.create()
def test_ip_max_invalid_character_validation(): """Test to validate max character for ip address field using random string""" prov = provider.OpenStackProvider( name=generate_random_string(size=5), hostname=generate_random_string(size=5), ip_address=generate_random_string(size=15)) prov.create() prov.delete(cancel=False)
def test_hostname_max_character_validation(): """Test to validate max character for hostname field""" prov = provider.OpenStackProvider( name=generate_random_string(size=5), hostname=generate_random_string(size=255), ip_address='10.10.10.10') prov.create() prov.delete(cancel=False)
def test_create_service_dialog(): dialog = ServiceDialog(label=rand.generate_random_string(), description="my dialog", submit=True, cancel=True, tab_label="tab_" + rand.generate_random_string(), tab_desc="my tab desc", box_label="box_" + rand.generate_random_string(), box_desc="my box desc", ele_label="ele_" + rand.generate_random_string(), ele_name=rand.generate_random_string(), ele_desc="my ele desc", choose_type="Text Box", default_text_box="default value") dialog.create()
def test_api_port_max_character_validation(): """Test to validate max character for api port field""" prov = provider.RHEVMProvider( name=generate_random_string(size=5), hostname=generate_random_string(size=5), ip_address='10.10.10.13', api_port=generate_random_string(size=15)) prov.create() prov.delete(cancel=False)
def dialog(): dlg = provisioning_dialogs.ProvisioningDialog( provisioning_dialogs.ProvisioningDialog.VM_PROVISION, name=generate_random_string(), description=generate_random_string() ) yield dlg if dlg.exists: dlg.delete()
def test_user_password_required_error_validation(): user = ac.User(name='user' + random.generate_random_string(), credential=Credential(principal='uid' + random.generate_random_string(), secret=None), email='*****@*****.**', group=group_user) with error.expected("Password_digest can't be blank"): user.create()
def test_vm_analysis_profile_crud(): """CRUD for VM analysis profiles.""" p = VMAnalysisProfile(generate_random_string(), generate_random_string(), files=["asdf", "dfg"]) p.create() with update(p): p.files = ["qwer"] with update(p): p.categories = ["check_system"] p.delete()
def test_api_port_blank_validation(): """Test to validate blank api port while adding a provider""" prov = provider.OpenStackProvider( name=generate_random_string(size=5), hostname=generate_random_string(size=5), ip_address='10.10.10.10', api_port='') prov.create() prov.delete(cancel=False)
def test_type_required_error_validation(): """Test to validate type in customization templates.""" template_name = pxe.CustomizationTemplate( name=generate_random_string(size=8), description=generate_random_string(size=16), image_type='RHEL-6', script_type='<Choose>', script_data='Testing the script') with error.expected('Type is required'): template_name.create()
def test_provisioning_dialog_crud(dialog): dialog.create() assert dialog.exists with update(dialog): dialog.name = generate_random_string() dialog.description = generate_random_string() assert dialog.exists dialog.change_type(provisioning_dialogs.ProvisioningDialog.HOST_PROVISION) assert dialog.exists dialog.delete() assert not dialog.exists
def single_task_permission_test(product_features, actions): '''Tests that action succeeds when product_features are enabled, and fail when everything but product_features are enabled''' test_permissions( _mk_role(name=random.generate_random_string(), product_features=[(['Everything'], False)] + [(f, True) for f in product_features]), actions, {}) test_permissions( _mk_role(name=random.generate_random_string(), product_features=[(['Everything'], True)] + [(f, False) for f in product_features]), {}, actions)
def test_pxe_image_type_required_error_validation(): """Test to validate pxe image type in customization templates.""" template_name = pxe.CustomizationTemplate( name=generate_random_string(size=8), description=generate_random_string(size=16), image_type='<Choose>', script_type='Kickstart', script_data='Testing the script') with error.expected("Pxe_image_type can't be blank"): template_name.create()
def test_pxe_image_type_required_error_validation(): """Test to validate pxe image type in customization templates.""" template_name = pxe.CustomizationTemplate( name=generate_random_string(size=8), description=generate_random_string(size=16), image_type='<Choose>', script_type='Kickstart', script_data='Testing the script') with error.expected("Pxe_image_type can't be blank"): template_name.create()
def test_type_required_error_validation(): """Test to validate type in customization templates.""" template_name = pxe.CustomizationTemplate( name=generate_random_string(size=8), description=generate_random_string(size=16), image_type='RHEL-6', script_type='<Choose>', script_data='Testing the script') with error.expected('Type is required'): template_name.create()
def dialog(): dialog = "dialog_" + generate_random_string() service_dialog = ServiceDialog(label=dialog, description="my dialog", submit=True, cancel=True, tab_label="tab_" + generate_random_string(), tab_desc="tab_desc", box_label="box_" + generate_random_string(), box_desc="box_desc", ele_label="ele_" + generate_random_string(), ele_name="service_name", ele_desc="ele_desc", choose_type="Text Box", default_text_box="default value") service_dialog.create() yield dialog
def test_name_max_character_validation(): """Test to validate name with maximum characters in customization templates.""" template_name = pxe.CustomizationTemplate( name=generate_random_string(size=256), description=generate_random_string(size=16), image_type='RHEL-6', script_type='Kickstart', script_data='Testing the script') with error.expected('Name is required'): template_name.create() template_name.delete(cancel=False)
def dialog(): dialog = "dialog_" + generate_random_string() service_dialog = ServiceDialog(label=dialog, description="my dialog", submit=True, cancel=True, tab_label="tab_" + generate_random_string(), tab_desc="tab_desc", box_label="box_" + generate_random_string(), box_desc="box_desc", ele_label="ele_" + generate_random_string(), ele_name="service_name", ele_desc="ele_desc", choose_type="Text Box", default_text_box="default value") service_dialog.create() flash.assert_success_message('Dialog "%s" was added' % dialog) yield dialog
def test_duplicate_name_error_validation(): """Test to validate duplication in customization templates.""" template_name = pxe.CustomizationTemplate( name=generate_random_string(size=8), description=generate_random_string(size=16), image_type='RHEL-6', script_type='Kickstart', script_data='Testing the script') template_name.create() with error.expected('Name has already been taken'): template_name.create() template_name.delete(cancel=False)
def test_customization_template_crud(): """Basic CRUD test for customization templates.""" template_crud = pxe.CustomizationTemplate( name=generate_random_string(size=8), description=generate_random_string(size=16), image_type='RHEL-6', script_type='Kickstart', script_data='Testing the script') template_crud.create() with update(template_crud): template_crud.name = template_crud.name + "_update" template_crud.delete(cancel=False)
def test_chartwidget_crud(): w = ChartWidget( generate_random_string(), description=generate_random_string(), active=True, filter="Configuration Management/Virtual Machines/Vendor and Guest OS", timer={"run": "Hourly", "hours": "Hour"}, visibility=["<By Role>", sel.ByText("EvmRole-administrator")] ) w.create() with update(w): w.active = False w.delete()
def test_reportwidget_crud(): w = ReportWidget( generate_random_string(), description=generate_random_string(), active=True, filter=["Events", "Operations", "Operations VMs Powered On/Off for Last Week"], columns=["VM Name", "Message"], rows="10", timer={"run": "Hourly", "hours": "Hour"}, visibility=["<By Role>", sel.ByText("EvmRole-administrator")] ) w.create() with update(w): w.active = False w.delete()
def test_menuwidget_crud(): w = MenuWidget( generate_random_string(), description=generate_random_string(), active=True, shortcuts={ "Services / Catalogs": generate_random_string(), "Clouds / Providers": generate_random_string(), }, visibility=["<By Role>", sel.ByText("EvmRole-administrator")] ) w.create() with update(w): w.active = False w.delete()
def test_create_service_dialog(): dialog = ServiceDialog(label=rand.generate_random_string(), description="my dialog", submit=True, cancel=True, tab_label="tab_" + rand.generate_random_string(), tab_desc="my tab desc", box_label="box_" + rand.generate_random_string(), box_desc="my box desc", ele_label="ele_" + rand.generate_random_string(), ele_name=rand.generate_random_string(), ele_desc="my ele desc", choose_type="Text Box", default_text_box="default value") dialog.create()
def test_dashboard_crud(): d = Dashboard( generate_random_string(), "EvmGroup-administrator", generate_random_string(), locked=False, widgets=["Top CPU Consumers (weekly)", "Vendor and Guest OS Chart"] ) d.create() with update(d): d.locked = True with update(d): d.locked = False with update(d): d.widgets = "Top Storage Consumers" d.delete()
def test_add_class_inherited(a_class): subclass = Class(name=generate_random_string(8), namespace=a_class.namespace, description="subclass", inherits_from=a_class) a_class.create() subclass.create()
def new_user(group=usergrp): return ac.User(name='user' + random.generate_random_string(), credential=new_credential(), email='*****@*****.**', group=group, cost_center='Workload', value_assign='Database')
def test_catalog_crud(): cat = Catalog(name=rand.generate_random_string(), description="my catalog") cat.create() with update(cat): cat.description = "my edited description" cat.delete()
def test_catalog_duplicate_name(): cat = Catalog(name=rand.generate_random_string(), description="my catalog") cat.create() with error.expected("Name has already been taken"): cat.create() cat.delete()
def test_user_email_error_validation(): user = ac.User(name='user' + random.generate_random_string(), credential=new_credential(), email='xyzdhat.com', group=group_user) with error.expected("Email must be a valid email address"): user.create()
def tag(category): tag = Tag(name=generate_lowercase_random_string(size=8), display_name=generate_random_string(size=32), category=category) tag.create() yield tag tag.delete()
def test_user_group_error_validation(): user = ac.User(name='user' + random.generate_random_string(), credential=new_credential(), email='*****@*****.**', group=None) with error.expected("A User must be assigned to a Group"): user.create()
def instance(setup_providers, provider_key, provider_mgmt, provisioning, provider_crud): # tries to delete the VM that gets created here vm_name = 'test_image_prov_%s' % generate_random_string() image = provisioning['image']['name'] note = ('Testing provisioning from image %s to vm %s on provider %s' % (image, vm_name, provider_crud.key)) instance = prov.Instance( name=vm_name, email='*****@*****.**', first_name='Image', last_name='Provisioner', notes=note, instance_type=provisioning['instance_type'], availability_zone=provisioning['availability_zone'], security_groups=[provisioning['security_group']], provider_mgmt=provider_mgmt, provider=provider_crud, guest_keypair="shared", template=prov.Template(image)) instance.create() yield instance try: logger.info('Cleaning up VM %s on provider %s' % (vm_name, provider_key)) provider_mgmt.delete_vm(vm_name) except: # The mgmt_sys classes raise Exception :\ logger.warning('Failed to clean up VM %s on provider %s' % (vm_name, provider_key))