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