def test_appliance_replicate_database_disconnection_with_backlog(request, vmware_provider):
"""Tests a database disconnection with backlog
Metadata:
test_flag: replication
"""
appl1, appl2 = get_replication_appliances()
def finalize():
appl1.destroy()
appl2.destroy()
request.addfinalizer(finalize)
appl1.ipapp.browser_steal = True
with appl1.ipapp:
configure_db_replication(appl2.address)
# Replication is up and running, now stop the DB on the replication parent
vmware_provider.create()
stop_db_process(appl2.address)
sleep(60)
start_db_process(appl2.address)
navigate_to(current_appliance.server.zone.region, 'Replication')
wait_for(lambda: conf.get_replication_status(navigate=False), fail_condition=False,
num_sec=360, delay=10, fail_func=sel.refresh, message="get_replication_status")
assert conf.get_replication_status()
wait_for_a_provider()
appl2.ipapp.browser_steal = True
with appl2.ipapp:
wait_for_a_provider()
assert vmware_provider.exists
def test_summary_pages_links(provider, cls):
navigate_to(cls.object, "All")
all_url = sel.current_url()
tb.select("List View")
name = choice([r[2].text for r in list_tbl.rows()])
obj = cls.object(name, provider)
obj.summary # <- reload summary
breads = breadcrumbs()
bread_names = map(sel.text_sane, breads)
if cls.breadcrumb_member.startswith("Container") and cls.breadcrumb_member not in bread_names:
breadcrumb_member = cls.breadcrumb_member.split(" ")[-1]
else:
breadcrumb_member = cls.breadcrumb_member
assert breadcrumb_member in bread_names
chosen_link = next(b for b in breads if sel.text_sane(b) == breadcrumb_member)
sel.click(chosen_link)
# TODO: replace with widgetastic view.is_displayed function when available
assert sel.current_url().split("?")[0] == all_url.split("?")[0]
def test_roles_summary(provider, soft_assert):
err_ptrn = '{} are shown incorrectly'
navigate_to(DeploymentRoles('', provider), 'AllForProvider')
roles_names = [q.name for q in Quadicon.all()]
for name in roles_names:
dr = DeploymentRoles(name, provider)
navigate_to(dr, 'DetailsFromProvider')
for v in ('Nodes', 'Direct VMs', 'All VMs'):
res = dr.get_detail('Relationships', v)
soft_assert(res.isdigit(), err_ptrn.format(v))
for v in ('Total CPUs', 'Total Node CPU Cores'):
res = dr.get_detail('Totals for Nodes', v)
soft_assert(res.isdigit() and int(res) > 0, err_ptrn.format(v))
total_cpu = dr.get_detail('Totals for Nodes', 'Total CPU Resources')
soft_assert('GHz' in total_cpu, err_ptrn.format('Total CPU Resources'))
total_memory = dr.get_detail('Totals for Nodes', 'Total Memory')
soft_assert('GB' in total_memory, err_ptrn.format('Total Memory'))
for v in ('Total Configured Memory', 'Total Configured CPUs'):
res = dr.get_detail('Totals for VMs', v)
soft_assert(res, err_ptrn.format(v))
def test_broken_angular_select(request):
"""Test that checks the fancy selects do not break.
Prerequisities:
* A fresh downstream appliance
Steps:
1) Create a catalog.
2) Create a catalog item, can be Generic and assign the catalog and OSE Installer dialog
for testing purposes
3) Try ordering the service, but instead of confirming the form, try changing some select.
"""
# OSE Installer dialog, one dropdown from it
the_select = AngularSelect("param_operatingSystemType")
cat = Catalog("Test_catalog_{}".format(fauxfactory.gen_alpha()))
cat.create()
request.addfinalizer(cat.delete)
item = CatalogItem(
item_type="Generic",
name="Catitem_{}".format(fauxfactory.gen_alpha()),
description=fauxfactory.gen_alpha(),
display_in=True,
catalog=cat.name,
dialog="azure-single-vm-from-user-image")
item.create()
request.addfinalizer(item.delete)
sc = service_catalogs.ServiceCatalogs(item.name)
navigate_to(sc, 'Order')
# The check itself
fill(the_select, "Linux")
assert not the_select.is_broken, "The select displayed itself next ot the angular select"
def load_details(self, refresh=False):
navigate_to(self, 'Details')
if not self.db_id or refresh:
tmp_ser = self.server(method='db')
self.db_id = tmp_ser.db_id
if refresh:
tb.refresh()
def edit_tags(self, tag, value):
navigate_to(self, 'Details')
policy_btn('Edit Tags', invokes_alert=True)
fill(edit_tags_form, {'select_tag': tag,
'select_value': value},
action=form_buttons.save)
flash.assert_success_message('Tag edits were successfully saved')
def load_details(self, refresh=False):
navigate_to(self, 'Details')
if not self.db_id or refresh:
tmp_dmn = self.domain(method='db')
self.db_id = tmp_dmn.db_id
if refresh:
tb.refresh()
def get_unassigned_policy_profiles(self):
""" Return a set of Policy Profiles which are available but not assigned.
Returns: :py:class:`set` of :py:class:`str` of Policy Profile names
"""
navigate_to(self, 'ManagePolicies')
return self._unassigned_policy_profiles
def update(self, updates):
navigate_to(self, 'Edit')
fill(basic_info_form, {'name_text': updates.get('name', None),
'description_text':
updates.get('description', None)},
action=basic_info_form.edit_button)
flash.assert_success_message('Service Catalog Item "{}" was saved'.format(self.name))
def load_details(self, refresh=False):
navigate_to(self, 'Details')
if not self.db_id or refresh:
tmp_msg = self.messaging(method='db')
self.db_id = tmp_msg.db_id
if refresh:
tb.refresh()
def test_pull_splitter_persistence(location):
navigate_to(*location)
# First we move splitter to hidden position by pulling it left twice
pull_splitter_left()
pull_splitter_left()
navigate_to(Server, 'Dashboard')
try:
navigate_to(*location)
except (TypeError, CannotScrollException):
# this exception is expected here since
# some navigation commands try to use accordion when it is hidden by splitter
pass
# Then we check hidden position splitter
if not pytest.sel.elements("//div[@id='left_div'][contains(@class, 'hidden-md')]"):
pytest.fail("Splitter did not persist when on hidden position!")
# Then we iterate over all the other positions
for position in ["col-md-2", "col-md-3", "col-md-4", "col-md-5"]:
# Pull splitter left
pull_splitter_right()
navigate_to(Server, 'Dashboard')
navigate_to(*location)
# Then check its position
if not pytest.sel.elements("//div[@id='left_div'][contains(@class, {})]"
.format(unescape(quoteattr(position)))):
pytest.fail("Splitter did not persist when on " + str(position) + " position!")
def queue_canned_report(cls, path):
"""Queue report from selection of pre-prepared reports.
Args:
*path: Path in tree after All Reports
Returns: Value of Run At in the table so the run can be then checked.
"""
cls.path = path
navigate_to(cls, "Info")
toolbar.select("Queue")
flash.assert_no_errors()
tabstrip.select_tab("Saved Reports")
queued_at = sel.text(list(records_table.rows())[0].queued_at)
def _get_state():
navigate_to(cls, 'Saved')
row = records_table.find_row("queued_at", queued_at)
status = sel.text(row.status).strip().lower()
assert status != "error", sel.text(row)
return status == version.pick({"5.6": "finished",
"5.7": "complete"})
wait_for(
_get_state,
delay=3,
message="wait for report generation finished",
fail_func=toolbar.refresh()
)
return sel.text(list(records_table.rows())[0].run_at).encode("utf-8")
def _get_state():
navigate_to(cls, 'Saved')
row = records_table.find_row("queued_at", queued_at)
status = sel.text(row.status).strip().lower()
assert status != "error", sel.text(row)
return status == version.pick({"5.6": "finished",
"5.7": "complete"})
def load_details(self, refresh=False):
navigate_to(self, 'Details')
if not self.db_id or refresh:
tmp_dsource = self.datasource(method='db')
self.db_id = tmp_dsource.db_id
if refresh:
tb.refresh()
def download(self, extension):
navigate_to(self, "Details")
extensions_mapping = {'txt': 'Text', 'csv': 'CSV', 'pdf': 'PDF'}
try:
download_btn("Download as {}".format(extensions_mapping[extension]))
except:
raise ValueError("Unknown extention. check the extentions_mapping")
def _get_tasks(tab_destination, **filter_kwargs):
""" Generic function to return contents of the tasks table
Args:
location: Location for :py:module:`ui_navigate` where to get the data.
**filter_kwargs: See :py:meth:`_filter`
Returns: List of dicts.
"""
navigate_to(Tasks, tab_destination)
if any([filter_kwargs[key] is not None for key in filter_kwargs.keys()]):
_filter(**filter_kwargs)
tasks = []
if sel.is_displayed(tasks_table):
for page in paginator.pages():
for row in tasks_table.rows():
tasks.append(
dict(
updated=parsetime.from_american_with_utc(
row.updated.text.encode('utf-8').strip()
),
started=parsetime.from_american_with_utc(
row.started.text.encode('utf-8').strip()
),
state=row.state.text.encode('utf-8').strip(),
message=row.message.text.encode('utf-8').strip(),
task_name=row.task_name.text.encode('utf-8').strip(),
user=row.user.text.encode('utf-8').strip()
)
)
else:
logger.info('No Tasks collected on {}'.format(tab_destination))
return tasks
def load_details(self):
# todo: to remove this context related functionality along with making provider
# param mandatory
if not self.provider:
navigate_to(self, 'Details')
else:
navigate_to(self, 'DetailsFromProvider')
def _provisioner(template, provisioning_data, delayed=None):
vm = Vm(name=vm_name, provider=provider, template_name=template)
navigate_to(vm, 'ProvisionVM')
fill(provisioning_form, provisioning_data, action=provisioning_form.submit_button)
flash.assert_no_errors()
request.addfinalizer(lambda: cleanup_vm(vm_name, provider))
if delayed is not None:
total_seconds = (delayed - datetime.utcnow()).total_seconds()
row_description = 'Provision from [{}] to [{}]'.format(template, vm_name)
cells = {'Description': row_description}
try:
row, __ = wait_for(requests.wait_for_request, [cells],
fail_func=requests.reload, num_sec=total_seconds, delay=5)
pytest.fail("The provisioning was not postponed")
except TimedOutError:
pass
logger.info('Waiting for vm %s to appear on provider %s', vm_name, provider.key)
wait_for(provider.mgmt.does_vm_exist, [vm_name], handle_exception=True, num_sec=600)
# nav to requests page happens on successful provision
logger.info('Waiting for cfme provision request for vm %s', vm_name)
row_description = 'Provision from [{}] to [{}]'.format(template, vm_name)
cells = {'Description': row_description}
row, __ = wait_for(requests.wait_for_request, [cells],
fail_func=requests.reload, num_sec=900, delay=20)
assert 'Successfully' in row.last_message.text and row.status.text != 'Error'
return vm
def all(cls):
"""Returns objects with all Widgets currently present."""
navigate_to(Server, 'Dashboard')
result = []
for el in sel.elements(cls._all):
result.append(cls(sel.get_attribute(el, "id")))
return result
def exists(self):
navigate_to(self, 'All')
for page in paginator.pages():
if sel.is_displayed(Quadicon(self.name, 'host')):
return True
else:
return False
def test_server_name():
"""Tests that changing the server name updates the about page"""
flash_msg = 'Configuration settings saved for CFME Server "{}'
navigate_to(current_appliance.server, 'Server')
old_server_name = sel.value(BasicInformation.basic_information.appliance_name)
new_server_name = old_server_name + "-CFME"
settings_pg = BasicInformation(appliance_name=new_server_name)
settings_pg.update()
flash.assert_message_contain(flash_msg.format(new_server_name))
# CFME updates about box only after any navigation BZ(1408681)
navigate_to(current_appliance.server, 'Dashboard')
# if version.current_version() < '5.7':
# current_server_name = InfoBlock('Session Information', 'Server Name').text
# navigate_to(current_appliance.server, 'About')
# else:
current_server_name = get_detail('Server Name')
close_button = sel.element('//div[contains(@class, "about-modal-pf")]//button[@class="close"]')
close_button.click()
assert new_server_name == current_server_name, \
"Server name in About section does not match the new name"
clear_property_cache(store.current_appliance, 'configuration_details')
settings_pg = BasicInformation(appliance_name=old_server_name)
settings_pg.update()
flash.assert_message_contain(flash_msg.format(old_server_name))
clear_property_cache(store.current_appliance, 'configuration_details')
def update(self, updates):
navigate_to(self, 'Edit')
# Workaround - form is appearing after short delay
sel.wait_for_element(self.tenant_form.description)
fill(self.tenant_form, updates, action=self.save_changes)
flash.assert_success_message(
'Project "{}" was saved'.format(updates.get('name', self.name)))
def create(self):
navigate_to(self, 'Add')
fill(self.form, {'name_txt': self.name,
'vm_restriction_select': self.vm_restriction,
'product_features_tree': self.product_features},
action=form_buttons.add)
flash.assert_success_message('Role "{}" was saved'.format(self.name))
def create(self):
navigate_to(self, 'Add')
fill(self.group_form, {'description_txt': self.description,
'role_select': self.role,
'group_tenant': self.tenant},
action=form_buttons.add)
flash.assert_success_message('Group "{}" was saved'.format(self.description))
def _retrieve_ext_auth_user_groups(self):
navigate_to(self, 'Add')
fill(self.group_form, {'lookup_ldap_groups_chk': True,
'user_to_look_up': self.user_to_lookup,
},)
sel.wait_for_element(form_buttons.retrieve)
sel.click(form_buttons.retrieve)
def exists(self):
try:
navigate_to(self, 'Details')
except CandidateNotFound:
return False
else:
return True
def delete(self, from_dest='All'):
"""
Delete the stack, starting from the destination provided by from_dest
@param from_dest: where to delete from, a valid navigation destination for Stack
"""
# Navigate to the starting destination
if from_dest in navigator.list_destinations(self):
navigate_to(self, from_dest)
else:
msg = 'cfme.cloud.stack does not have destination {}'.format(from_dest)
raise DestinationNotFound(msg)
# Delete using the method appropriate for the starting destination
if from_dest == 'All':
sel.check(Quadicon(self.name, self.quad_name).checkbox())
cfg_btn("Remove Orchestration Stacks", invokes_alert=True)
elif from_dest == 'Details':
cfg_btn("Remove this Orchestration Stack", invokes_alert=True)
sel.handle_alert()
# The delete initiated message may get missed if the delete is fast
try:
flash.assert_message_contain("Delete initiated for 1 Orchestration Stacks")
except FlashMessageException as ex:
if 'No flash message contains' in ex.message:
flash.assert_message_contain("The selected Orchestration Stacks was deleted")
self.wait_for_delete()
def update(self, updates):
navigate_to(self, 'Edit')
fill(self.form, {'name_txt': updates.get('name'),
'vm_restriction_select': updates.get('vm_restriction'),
'product_features_tree': updates.get('product_features')},
action=form_buttons.save)
flash.assert_success_message('Role "{}" was saved'.format(updates.get('name', self.name)))
def discover(credential, cancel=False, d_type="Amazon"):
"""
Discover cloud providers. Note: only starts discovery, doesn't
wait for it to finish.
Args:
credential (cfme.Credential): Amazon discovery credentials.
cancel (boolean): Whether to cancel out of the discover UI.
"""
navigate_to(CloudProvider, "Discover")
form_data = {"discover_select": d_type}
if credential:
form_data.update(
{
"username": credential.principal,
"password": credential.secret,
"password_verify": credential.verify_secret,
}
)
fill(
discover_form,
form_data,
action=form_buttons.cancel if cancel else discover_form.start_button,
action_always=True,
)
def order(self):
navigate_to(self, 'Order')
if self.stack_data:
stack_form.fill(self.stack_data)
sel.click(form_buttons.submit)
wait_for(flash.get_messages, num_sec=10, delay=2, fail_condition=[], fail_func=tb.refresh())
flash.assert_success_message("Order Request was Submitted")
def download_file(self, extension):
view = navigate_to(self, 'All')
view.download_choice.item_select("Download as " + extension)
view.flash.assert_no_error()
def test_host_provisioning(setup_provider, cfme_data, host_provisioning, provider, smtp_test,
request):
"""Tests host provisioning
Metadata:
test_flag: host_provision
"""
# Add host before provisioning
test_host = host.get_from_config('esx')
test_host.create()
# Populate provisioning_data before submitting host provisioning form
pxe_server, pxe_image, pxe_image_type, pxe_kickstart, datacenter, cluster, datastores,\
prov_host_name, root_password, ip_addr, subnet_mask, gateway, dns = map(
host_provisioning.get,
('pxe_server', 'pxe_image', 'pxe_image_type', 'pxe_kickstart', 'datacenter', 'cluster',
'datastores', 'hostname', 'root_password', 'ip_addr', 'subnet_mask', 'gateway', 'dns'))
def cleanup_host():
try:
logger.info('Cleaning up host %s on provider %s', prov_host_name, provider.key)
mgmt_system = provider.mgmt
host_list = mgmt_system.list_host()
if host_provisioning['ip_addr'] in host_list:
wait_for(mgmt_system.is_host_connected, [host_provisioning['ip_addr']])
mgmt_system.remove_host_from_cluster(host_provisioning['ip_addr'])
ipmi = test_host.get_ipmi()
ipmi.power_off()
# During host provisioning,the host name gets changed from what's specified at creation
# time.If host provisioning succeeds,the original name is reverted to,otherwise the
# changed names are retained upon failure
renamed_host_name1 = "{} ({})".format('IPMI', host_provisioning['ipmi_address'])
renamed_host_name2 = "{} ({})".format('VMware ESXi', host_provisioning['ip_addr'])
host_list_ui = host.get_all_hosts()
if host_provisioning['hostname'] in host_list_ui:
test_host.delete(cancel=False)
host.wait_for_host_delete(test_host)
elif renamed_host_name1 in host_list_ui:
host_renamed_obj1 = host.Host(name=renamed_host_name1, provider=provider)
host_renamed_obj1.delete(cancel=False)
host.wait_for_host_delete(host_renamed_obj1)
elif renamed_host_name2 in host_list_ui:
host_renamed_obj2 = host.Host(name=renamed_host_name2, provider=provider)
host_renamed_obj2.delete(cancel=False)
host.wait_for_host_delete(host_renamed_obj2)
except:
# The mgmt_sys classes raise Exception :\
logger.warning('Failed to clean up host %s on provider %s',
prov_host_name, provider.key)
request.addfinalizer(cleanup_host)
navigate_to(test_host, 'Provision')
note = ('Provisioning host {} on provider {}'.format(prov_host_name, provider.key))
provisioning_data = {
'email': '*****@*****.**',
'first_name': 'Template',
'last_name': 'Provisioner',
'notes': note,
'pxe_server': pxe_server,
'pxe_image': {'name': [pxe_image]},
'provider_name': provider.name,
'cluster': "{} / {}".format(datacenter, cluster),
'datastore_name': {'name': datastores},
'root_password': root_password,
'prov_host_name': prov_host_name,
'ip_address': ip_addr,
'subnet_mask': subnet_mask,
'gateway': gateway,
'dns_servers': dns,
'custom_template': {'name': [pxe_kickstart]},
}
fill(provisioning_form, provisioning_data, action=provisioning_form.host_submit_button)
flash.assert_success_message(
"Host Request was Submitted, you will be notified when your Hosts are ready")
row_description = 'PXE install on [{}] from image [{}]'.format(prov_host_name, pxe_image)
cells = {'Description': row_description}
row, __ = wait_for(requests.wait_for_request, [cells],
fail_func=requests.reload, num_sec=1500, delay=20)
assert row.last_message.text == 'Host Provisioned Successfully'
assert row.status.text != 'Error'
# Navigate to host details page and verify Provider and cluster names
assert test_host.get_detail('Relationships', 'Infrastructure Provider') ==\
provider.name, 'Provider name does not match'
assert test_host.get_detail('Relationships', 'Cluster') ==\
host_provisioning['cluster'], 'Cluster does not match'
# Navigate to host datastore page and verify that the requested datastore has been assigned
# to the host
requested_ds = host_provisioning['datastores']
datastores = test_host.get_datastores()
assert set(requested_ds).issubset(datastores), 'Datastores are missing some members'
# Wait for e-mails to appear
def verify():
return len(
smtp_test.get_emails(
subject_like="Your host provisioning request has Completed - Host:%%".format(
prov_host_name))
) > 0
wait_for(verify, message="email receive check", delay=5)
def zone(self):
view = navigate_to(self, 'Details')
return view.entities.relationships.get_text_of('Zone')
def parent_provider(self):
""" Return object of parent cloud provider """
view = navigate_to(self, 'Details')
provider_name = view.entities.relationships.get_text_of(
'Parent ems cloud')
return providers.get_crud_by_name(provider_name)
def _go_to(cls, dest='All'):
"""Create a thunk that navigates to the given destination"""
return lambda: navigate_to(cls, dest)
def _test_vm_provision():
logger.info("Checking for provision access")
navigate_to(vms.Vm, 'VMsOnly')
vms.lcl_btn("Provision VMs")
def test_edit_default_roles():
role = Role(name='EvmRole-auditor')
navigate_to(role, 'Edit')
flash.assert_message_match(
"Read Only Role \"{}\" can not be edited".format(role.name))
def exists(self):
try:
navigate_to(self, 'Details')
return True
except CandidateNotFound:
return False
def is_ad_hoc_greyed(provider_object):
view = navigate_to(provider_object, 'Details')
return view.monitor.item_enabled('Ad hoc Metrics')
def check_vm_add(self, add_vm_name):
view = navigate_to(self, 'Details')
# TODO - replace Quadicon later
quadicon = Quadicon(add_vm_name, "vm")
sel.click(quadicon)
view.flash.assert_no_error()
def import_reports(filename, overwrite=False):
view = navigate_to(Server, "ImportExportCustomReports")
assert view.is_displayed
view.fill({"overwrite": overwrite, "upload_file": filename})
view.upload_button.click()
view.flash.assert_no_error()
def group_order(self):
view = navigate_to(Group, 'EditGroupSequence')
return view.group_order_selector.items
def untag(self, tag):
"""Removes the selected tag off the system"""
navigate_to(self, 'Details')
mixins.remove_tag(tag)
def export_widgets(*widget_names):
view = navigate_to(Server, "ImportExportWidgets")
assert view.is_displayed
view.fill({"items_for_export": list(widget_names)})
view.export_button.click()
def power_off(self):
view = navigate_to(self, "Details")
view.toolbar.power.item_select("Power Off", handle_alert=True)
def export_reports(*custom_report_names):
view = navigate_to(Server, "ImportExportCustomReports")
assert view.is_displayed
view.fill({"items_for_export": list(custom_report_names)})
view.export_button.click()
def headers(cls):
navigate_to(MiddlewareServer, 'All')
headers = [sel.text(hdr).encode("utf-8")
for hdr in sel.elements("//thead/tr/th") if hdr.text]
return headers
def tag(self, tag, **kwargs):
"""Tags the system by given tag"""
navigate_to(self, 'Details')
mixins.add_tag(tag, **kwargs)
def get_all_hosts(do_not_navigate=False):
"""Returns list of all hosts"""
if not do_not_navigate:
navigate_to(Host, 'All')
return [q.name for q in Quadicon.all("host")]
def execute_button(self, button_group, button, handle_alert=False):
view = navigate_to(self, "Details")
view.toolbar.custom_button(button_group).item_select(
button, handle_alert=handle_alert)
def wait_for_host_delete(host):
navigate_to(Host, 'All')
quad = Quadicon(host.name, 'host')
logger.info('Waiting for a host to delete...')
wait_for(lambda: not sel.is_displayed(quad), fail_condition=False,
message="Wait host to disappear", num_sec=500, fail_func=sel.refresh)
def _get_domains_page(provider):
if provider: # if provider instance is provided navigate through provider's domains page
navigate_to(provider, 'ProviderDomains')
else: # if None(provider) given navigate through all middleware domains page
navigate_to(MiddlewareDomain, 'All')
def get_datastores(self):
""" Gets list of all datastores used by this host"""
navigate_to(self, 'Details')
list_acc.select('Relationships', 'Datastores', by_title=False, partial=True)
return [q.name for q in Quadicon.all("datastore")]
def wait_for_host_to_appear(host):
navigate_to(Host, 'All')
quad = Quadicon(host.name, 'host')
logger.info('Waiting for a host to appear...')
wait_for(sel.is_displayed, func_args=[quad], fail_condition=False,
message="Wait host to appear", num_sec=1000, fail_func=sel.refresh)
def load_details(self, refresh=False):
"""To be compatible with the Taggable and PolicyProfileAssignable mixins."""
navigate_to(self, 'Details')
if refresh:
sel.refresh()
def wait_for_a_host():
navigate_to(Host, 'All')
logger.info('Waiting for a host to appear...')
wait_for(paginator.rec_total, fail_condition=None, message="Wait for any host to appear",
num_sec=1000, fail_func=sel.refresh)
def update(self, updates):
view = navigate_to(self, 'Edit')
view.fill_with(updates, on_change=view.save_button, no_change=view.cancel_button)
view.flash.assert_success_message('Chargeback Rate "{}" was saved'.format(
updates.get('description')))
def power_off(self):
navigate_to(self, 'Details')
pow_btn('Power Off', invokes_alert=True)
sel.handle_alert()
def default_widgets():
view = navigate_to(DefaultDashboard(), 'Details')
return view.selected_items
def delete(self):
view = navigate_to(self, 'Details')
view.configuration.item_select('Remove from the VMDB', handle_alert=True)
view.flash.assert_success_message('Chargeback Rate "{}": Delete successful'.format(
self.description))
