def create(self):
sel.force_navigate('catalog_item_new',
context={'provider_type': self.item_type})
sel.wait_for_element(basic_info_form.name_text)
fill(basic_info_form, {'name_text': self.name,
'description_text': self.description,
'display_checkbox': self.display_in,
'select_catalog': self.catalog,
'select_dialog': self.dialog,
'select_orch_template': self.orch_template,
'select_provider': self.provider_type})
if current_version() >= "5.4":
sel.click(basic_info_form.field_entry_point)
dynamic_tree.click_path("Datastore", self.domain, "Service", "Provisioning",
"StateMachines", "ServiceProvision_Template", "default")
sel.click(basic_info_form.apply_btn)
if(self.catalog_name is not None):
tabstrip.select_tab("Request Info")
template = template_select_form.template_table.find_row_by_cells({
'Name': self.catalog_name,
'Provider': self.provider
})
sel.click(template)
request_form.fill(self.provisioning_data)
sel.click(template_select_form.add_button)
def create(self):
view = navigate_to(self, 'BundleAdd')
domain = "ManageIQ (Locked)"
view.fill({
'name': self.name,
'description': self.description,
'display': self.display_in,
'select_catalog': self.catalog.name,
'select_dialog': self.dialog
})
if view.field_entry_point.value == "":
view.fill({'field_entry_point': ''})
view.tree.click_path("Datastore", domain, "Service",
"Provisioning", "StateMachines",
"ServiceProvision_Template",
"CatalogItemInitialization")
view.apply_button.click()
tabstrip.select_tab("Resources")
for cat_item in self.catalog_items:
view.fill({'select_resource': cat_item})
view.add_button.click()
view.flash.assert_success_message(
'Catalog Bundle "{}" was added'.format(self.name))
view = self.create_view(AllCatalogItemView)
assert view.is_displayed
view.flash.assert_no_error()
def create(self):
domain = "ManageIQ (Locked)"
sel.force_navigate('catalog_item_new', context={'provider_type': self.item_type})
sel.wait_for_element(basic_info_form.name_text)
fill(basic_info_form, {'name_text': self.name,
'description_text': self.description,
'display_checkbox': self.display_in,
'select_catalog': self.catalog,
'select_dialog': self.dialog})
if self.item_type != "Orchestration":
sel.click(basic_info_form.field_entry_point)
dynamic_tree.click_path("Datastore", domain, "Service", "Provisioning",
"StateMachines", "ServiceProvision_Template", "default")
sel.click(basic_info_form.apply_btn)
tabstrip.select_tab("Request Info")
template = template_select_form.template_table.find_row_by_cells({
'Name': self.catalog_name,
'Provider': self.provider
})
sel.click(template)
web_ui.fill(request_form, {
'instance_name': self.vm_name,
'instance_type': self.instance_type,
'guest_keypair': self.guest_keypair,
'availability_zone': self.availability_zone,
'cloud_tenant': self.cloud_tenant,
'cloud_network': self.cloud_network,
'security_groups': self.security_groups[0], # not supporting multiselect now,
# just take first value
})
sel.click(template_select_form.add_button)
flash.assert_success_message('Service Catalog Item "%s" was added' % self.name)
def create(self):
sel.force_navigate('catalog_item_new',
context={'provider_type': self.item_type})
fill(
basic_info_form, {
'name_text': self.name,
'description_text': self.description,
'display_checkbox': self.display_in,
'select_catalog': self.catalog,
'select_dialog': self.dialog
})
tabstrip.select_tab("Request Info")
template = template_select_form.template_table.find_row_by_cells({
'Name':
self.catalog_name,
'Provider':
self.provider
})
sel.click(template)
web_ui.fill(
request_form,
{
'instance_name': self.vm_name,
'instance_type': self.instance_type,
'guest_keypair': self.guest_keypair,
'availability_zone': self.availability_zone,
'security_groups':
self.security_groups[0], # not supporting multiselect now,
# just take first value
})
sel.click(template_select_form.add_button)
flash.assert_success_message('Service Catalog Item "%s" was added' %
self.name)
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 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 queue(self, wait_for_finish=False):
navigate_to(self, 'Details')
toolbar.select("Queue")
flash.assert_no_errors()
tabstrip.select_tab("Saved Reports")
if wait_for_finish:
# Get the queued_at value to always target the correct row
queued_at = sel.text(list(records_table.rows())[0].queued_at)
def _get_state():
navigate_to(self, '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=1,
message="wait for report generation finished",
fail_func=toolbar.refresh(),
num_sec=300,
)
def create(self):
sel.force_navigate('catalog_item_new', context={'provider_type': self.item_type})
sel.wait_for_element(basic_info_form.name_text)
fill(basic_info_form, {'name_text': self.name,
'description_text': self.description,
'display_checkbox': self.display_in,
'select_catalog': self.catalog,
'select_dialog': self.dialog})
tabstrip.select_tab("Request Info")
template = template_select_form.template_table.find_row_by_cells({
'Name': self.catalog_name,
'Provider': self.provider
})
sel.click(template)
web_ui.fill(request_form, {
'instance_name': self.vm_name,
'instance_type': self.instance_type,
'guest_keypair': self.guest_keypair,
'availability_zone': self.availability_zone,
'cloud_tenant': self.cloud_tenant,
'cloud_network': self.cloud_network,
'security_groups': self.security_groups[0], # not supporting multiselect now,
# just take first value
})
sel.click(template_select_form.add_button)
flash.assert_success_message('Service Catalog Item "%s" was added' % self.name)
def queue_canned_report(*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.
"""
sel.force_navigate("report_canned_info", context={"path": path})
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():
row = records_table.find_row("queued_at", queued_at)
status = sel.text(row.status).strip().lower()
assert status != "error", sel.text(row)
return status == "finished"
wait_for(
_get_state,
delay=1,
message="wait for report generation finished",
fail_func=reload_view
)
return sel.text(list(records_table.rows())[0].run_at).encode("utf-8")
def queue_canned_report(*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.
"""
sel.force_navigate("report_canned_info", context={"path": path})
toolbar.select("Queue")
flash.assert_no_errors()
tabstrip.select_tab("Saved Reports")
def _get_state():
try:
first_row = list(records_table.rows())[0]
except IndexError:
return False
return sel.text(first_row.status).strip().lower() == "finished"
wait_for(
_get_state,
delay=1,
message="wait for report generation finished",
fail_func=reload_view
)
return sel.text(list(records_table.rows())[0].run_at).encode("utf-8")
def create(self):
sel.force_navigate('catalog_item_new',
context={'provider_type': self.item_type})
sel.wait_for_element(basic_info_form.name_text)
fill(
basic_info_form, {
'name_text': self.name,
'description_text': self.description,
'display_checkbox': self.display_in,
'select_catalog': self.catalog,
'select_dialog': self.dialog,
'select_orch_template': self.orch_template,
'select_provider': self.provider_type
})
if self.item_type != "Orchestration":
sel.click(basic_info_form.field_entry_point)
dynamic_tree.click_path("Datastore", self.domain, "Service",
"Provisioning", "StateMachines",
"ServiceProvision_Template", "default")
sel.click(basic_info_form.apply_btn)
if (self.catalog_name is not None):
tabstrip.select_tab("Request Info")
template = template_select_form.template_table.find_row_by_cells({
'Name':
self.catalog_name,
'Provider':
self.provider
})
sel.click(template)
request_form.fill(self.provisioning_data)
sel.click(template_select_form.add_button)
def create(self):
view = navigate_to(self, 'Add')
# Need to provide the (optional) provider name to the form, not the object
provider_formvalue = None
if self.item_type == 'Orchestration':
provider_formvalue = self.provider.name
elif self.item_type == 'AnsibleTower':
provider_formvalue = self.provider
# For tests where orchestration template is None
view.before_filling()
view.fill({
'name':
self.name,
'description':
self.description,
'display':
self.display_in,
'select_catalog':
self.catalog.name,
'select_dialog':
self.dialog,
'select_orch_template':
self.orch_template.template_name if self.orch_template else None,
'select_provider':
provider_formvalue,
'select_config_template':
self.config_template
})
if view.field_entry_point.value == "":
view.fill({'field_entry_point': 'a'})
view.tree.click_path("Datastore", self.domain, "Service",
"Provisioning", "StateMachines",
"ServiceProvision_Template",
"CatalogItemInitialization")
view.apply_button.click()
if self.appliance.version >= "5.7" and self.item_type == "AnsibleTower":
view.fill({'retirement_entry_point': 'b'})
view.tree.click_path("Datastore", self.domain, "Service",
"Retirement", "StateMachines",
"ServiceRetirement", "Generic")
view.apply_button.click()
if self.catalog_name is not None \
and self.provisioning_data is not None \
and not isinstance(self.provider, NoneType):
tabstrip.select_tab("Request Info")
tabstrip.select_tab("Catalog")
row = view.template_table.row(name=self.catalog_name,
provider=self.provider.name)
row.click()
provisioning_view = self.create_view(BasicProvisionFormView)
provisioning_view.fill_with(self.provisioning_data)
view.add_button.click()
view.flash.assert_success_message(
'Service Catalog Item "{}" was added'.format(self.name))
view = self.create_view(AllCatalogItemView)
assert view.is_displayed
def _refresh():
""" The page has no refresh button, so we'll switch between tabs.
Why this? Selenium's refresh() is way too slow. This is much faster.
"""
tabs.select_tab("Workers")
tabs.select_tab("Collect Logs") # Serve as the refresh
def create(self):
# Create has sequential forms, the first is only the provider type
navigate_to(self, 'Add')
# For element not found exception (To be removed)
sel.sleep(5)
sel.select("//select[@id='st_prov_type']",
self.provider_type or self.item_type or 'Generic')
sel.wait_for_element(basic_info_form.name_text)
catalog = fakeobject_or_object(self.catalog, "name", "Unassigned")
dialog = fakeobject_or_object(self.dialog, "name", "No Dialog")
# Need to provide the (optional) provider name to the form, not the object
provider_name = None
provider_required_types = ['AnsibleTower', 'Orchestration']
if self.item_type in provider_required_types \
or self.provider_type in provider_required_types:
provider_name = self.provider.name
# For tests where orchestration template is None
orch_template = None
if self.orch_template:
orch_template = self.orch_template.template_name
fill(basic_info_form, {'name_text': self.name,
'description_text': self.description,
'display_checkbox': self.display_in,
'select_catalog': catalog.name,
'select_dialog': dialog.name,
'select_orch_template': orch_template,
'select_provider': provider_name,
'select_config_template': self.config_template})
if not (self.item_type in provider_required_types):
sel.click(basic_info_form.field_entry_point)
if version.current_version() < "5.7":
dynamic_tree.click_path("Datastore", self.domain, "Service", "Provisioning",
"StateMachines", "ServiceProvision_Template", "default")
else:
entry_tree.click_path("Datastore", self.domain, "Service", "Provisioning",
"StateMachines", "ServiceProvision_Template", "default")
sel.click(basic_info_form.apply_btn)
if version.current_version() >= "5.7" and self.item_type == "AnsibleTower":
sel.click(basic_info_form.retirement_entry_point)
entry_tree.click_path("Datastore", self.domain, "Service", "Retirement",
"StateMachines", "ServiceRetirement", "Generic")
sel.click(basic_info_form.apply_btn)
if self.catalog_name is not None \
and self.provisioning_data is not None \
and not isinstance(self.provider, NoneType):
tabstrip.select_tab("Request Info")
tabstrip.select_tab("Catalog")
template = template_select_form.template_table.find_row_by_cells({
'Name': self.catalog_name,
'Provider': self.provider.name
})
sel.click(template)
request_form.fill(self.provisioning_data)
sel.click(template_select_form.add_button)
def update(self, updates):
sel.force_navigate('catalog_bundle_edit',
context={'catalog': self.catalog, 'catalog_bundle': self})
fill(basic_info_form, {'name_text': updates.get('name', None),
'description_text': updates.get('description', None)})
tabstrip.select_tab("Resources")
fill(resources_form, {'choose_resource': updates.get('cat_item', None)},
action=resources_form.save_button)
flash.assert_success_message('Catalog Bundle "%s" was saved' % self.name)
def dashboards():
"""Returns a generator that iterates through the available dashboards"""
sel.force_navigate("dashboard")
# We have to click any other of the tabs (glitch)
# Otherwise the first one is not displayed (O_O)
tabstrip.select_tab(tabstrip.get_all_tabs()[-1])
for dashboard_name in tabstrip.get_all_tabs():
tabstrip.select_tab(dashboard_name)
yield dashboard_name
def dashboards():
"""Returns a generator that iterates through the available dashboards"""
sel.force_navigate("dashboard")
# We have to click any other of the tabs (glitch)
# Otherwise the first one is not displayed (O_O)
tabstrip.select_tab(tabstrip.get_all_tabs()[-1])
for dashboard_name in tabstrip.get_all_tabs():
tabstrip.select_tab(dashboard_name)
yield dashboard_name
def update(self, updates):
navigate_to(self, 'Edit')
fill(basic_info_form, {'name_text': updates.get('name', None),
'description_text':
updates.get('description', None)})
tabstrip.select_tab("Resources")
fill(resources_form, {'choose_resource':
updates.get('cat_item', None)},
action=resources_form.save_button)
flash.assert_success_message('Catalog Bundle "{}" was saved'.format(self.name))
def create(self):
sel.force_navigate('catalog_bundle_new')
fill(basic_info_form, {'name_text': self.name,
'description_text': self.description,
'display_checkbox': self.display_in,
'select_catalog': self.catalog,
'select_dialog': self.dialog})
tabstrip.select_tab("Resources")
fill(resources_form, {'choose_resource': self.cat_item},
action=resources_form.add_button)
flash.assert_success_message('Catalog Bundle "%s" was added' % self.name)
def update(self, updates):
sel.force_navigate('catalog_bundle_edit',
context={'catalog': self.catalog,
'catalog_bundle': self})
fill(basic_info_form, {'name_text': updates.get('name', None),
'description_text':
updates.get('description', None)})
tabstrip.select_tab("Resources")
fill(resources_form, {'choose_resource':
updates.get('cat_item', None)},
action=resources_form.save_button)
flash.assert_success_message('Catalog Bundle "{}" was saved'.format(self.name))
def systems(self):
"""Returns 'ConfigSystem' objects that are active under this profile"""
self.navigate()
# ajax wait doesn't work here
_header_loc = "//div[contains(@class, 'dhtmlxInfoBarLabel')"\
" and contains(normalize-space(text()), 'Configured Systems')]"
sel.wait_for_element(_header_loc)
# Unassigned config profile has no tabstrip
if "unassigned" not in self.name.lower():
tabs.select_tab("Configured Systems")
if sel.is_displayed(list_table):
return [ConfigSystem(row['description'].text, self) for row in list_table.rows()]
return list()
def create(self):
sel.force_navigate('catalog_item_new', context={'provider_type': self.item_type})
fill(basic_info_form, {'name_text': self.name,
'description_text': self.description,
'display_checkbox': self.display_in,
'select_catalog': self.catalog,
'select_dialog': self.dialog})
tabstrip.select_tab("Request Info")
template = template_select_form.template_table.find_row_by_cells({
'Name': self.catalog_name,
'Provider': self.provider
})
sel.click(template)
request_form.fill(self.provisioning_data)
sel.click(template_select_form.add_button)
def create(self):
sel.force_navigate('catalog_bundle_new')
fill(
basic_info_form, {
'name_text': self.name,
'description_text': self.description,
'display_checkbox': self.display_in,
'select_catalog': self.catalog,
'select_dialog': self.dialog
})
tabstrip.select_tab("Resources")
fill(resources_form, {'choose_resource': self.cat_item},
action=resources_form.add_button)
flash.assert_success_message('Catalog Bundle "%s" was added' %
self.name)
def systems(self):
"""Returns 'ConfigSystem' objects that are active under this profile"""
self.navigate()
# ajax wait doesn't work here
_header_loc = "//div[contains(@class, 'dhtmlxInfoBarLabel')"\
" and contains(normalize-space(text()), 'Configured Systems')]"
sel.wait_for_element(_header_loc)
# Unassigned config profile has no tabstrip
if "unassigned" not in self.name.lower():
tabs.select_tab("Configured Systems")
if sel.is_displayed(list_table):
return [
ConfigSystem(row['description'].text, self)
for row in list_table.rows()
]
return list()
def create(self):
sel.force_navigate('catalog_item_new', context={'provider_type': self.item_type})
fill(basic_info_form, {'name_text': self.name,
'description_text': self.description,
'display_checkbox': self.display_in,
'select_catalog': self.catalog,
'select_dialog': self.dialog})
if(self.item_type is not "Generic"):
tabstrip.select_tab("Request Info")
template = template_select_form.template_table.find_row_by_cells({
'Name': self.catalog_name,
'Provider': self.provider
})
sel.click(template)
request_form.fill(self.provisioning_data)
sel.click(template_select_form.add_button)
flash.assert_success_message('Service Catalog Item "%s" was added' % self.name)
def update(self, updates):
view = navigate_to(self, 'BundleEdit')
tabstrip.select_tab("Resources")
changed = view.fill({'select_resource': updates.get('catalog_items')})
if changed:
view.save_button.click()
else:
view.cancel_button.click()
if changed:
view.flash.assert_success_message(
'Catalog Bundle "{}" was saved'.format(updates.get('name', self.name)))
else:
view.flash.assert_success_message(
'Edit of Catalog Bundle"{}" was cancelled by the user'.format(self.name))
view = self.create_view(DetailsCatalogItemView, override=updates)
assert view.is_displayed
view.flash.assert_no_error()
def systems(self):
"""Returns 'ConfigSystem' objects that are active under this profile"""
navigate_to(self, 'Details')
# ajax wait doesn't work here
_title_loc = "//span[contains(@id, 'explorer_title_text') " \
"and contains(normalize-space(text()), 'Configured Systems')]"
sel.wait_for_element(_title_loc)
# Unassigned config profile has no tabstrip
if "unassigned" not in self.name.lower():
tabs.select_tab("Configured Systems")
if sel.is_displayed(page.list_table_config_systems):
row_key = 'hostname'
return [ConfigSystem(row[row_key].text, self) for row in
page.list_table_config_systems.rows()]
return list()
def create(self):
view = navigate_to(self, 'Add')
# Need to provide the (optional) provider name to the form, not the object
provider_formvalue = None
if self.item_type == 'Orchestration':
provider_formvalue = self.provider.name
elif self.item_type == 'AnsibleTower':
provider_formvalue = self.provider
# For tests where orchestration template is None
view.before_filling()
view.fill({'name': self.name,
'description': self.description,
'display': self.display_in,
'select_catalog': self.catalog.name,
'select_dialog': self.dialog,
'select_orch_template': self.orch_template.template_name
if self.orch_template else None,
'select_provider': provider_formvalue,
'select_config_template': self.config_template})
if view.field_entry_point.value == "":
view.fill({'field_entry_point': 'a'})
view.tree.click_path(
"Datastore", self.domain, "Service", "Provisioning",
"StateMachines", "ServiceProvision_Template", "CatalogItemInitialization")
view.apply_button.click()
if self.appliance.version >= "5.7" and self.item_type == "AnsibleTower":
view.fill({'retirement_entry_point': 'b'})
view.tree.click_path(
"Datastore", self.domain, "Service", "Retirement",
"StateMachines", "ServiceRetirement", "Generic")
view.apply_button.click()
if self.catalog_name is not None \
and self.provisioning_data is not None \
and not isinstance(self.provider, NoneType):
tabstrip.select_tab("Request Info")
tabstrip.select_tab("Catalog")
row = view.template_table.row(name=self.catalog_name, provider=self.provider.name)
row.click()
request_form.fill(self.provisioning_data)
view.add_button.click()
view.flash.assert_success_message('Service Catalog Item "{}" was added'.format(self.name))
view = self.create_view(AllCatalogItemView)
assert view.is_displayed
def update(self, updates):
view = navigate_to(self, 'BundleEdit')
changed = view.fill(updates)
tabstrip.select_tab("Resources")
view.fill({'select_resource': updates.get('catalog_items', None)},)
if changed:
view.save_button.click()
else:
view.cancel_button.click()
if changed:
view.flash.assert_success_message(
'Catalog Bundle "{}" was saved'.format(updates.get('name', self.name)))
else:
view.flash.assert_success_message(
'Edit of Catalog Bundle"{}" was cancelled by the user'.format(self.name))
view = self.create_view(DetailsCatalogItemView, override=updates)
assert view.is_displayed
view.flash.assert_no_error()
def create(self, cat_items):
sel.force_navigate('catalog_bundle_new')
domain = "ManageIQ (Locked)"
fill(basic_info_form, {'name_text': self.name,
'description_text': self.description,
'display_checkbox': self.display_in,
'select_catalog': str(self.catalog),
'select_dialog': str(self.dialog)})
if current_version().is_in_series("5.3"):
sel.click(basic_info_form.field_entry_point)
dynamic_tree.click_path("Datastore", domain, "Service", "Provisioning",
"StateMachines", "ServiceProvision_Template", "default")
sel.click(basic_info_form.apply_btn)
tabstrip.select_tab("Resources")
for cat_item in cat_items:
fill(resources_form, {'choose_resource': cat_item})
sel.click(resources_form.add_button)
flash.assert_success_message('Catalog Bundle "{}" was added'.format(self.name))
def create(self, cat_items):
sel.force_navigate('catalog_bundle_new')
domain = "ManageIQ (Locked)"
fill(basic_info_form, {'name_text': self.name,
'description_text': self.description,
'display_checkbox': self.display_in,
'select_catalog': str(self.catalog),
'select_dialog': str(self.dialog)})
if current_version().is_in_series("5.3"):
sel.click(basic_info_form.field_entry_point)
dynamic_tree.click_path("Datastore", domain, "Service", "Provisioning",
"StateMachines", "ServiceProvision_Template", "default")
sel.click(basic_info_form.apply_btn)
tabstrip.select_tab("Resources")
for cat_item in cat_items:
fill(resources_form, {'choose_resource': cat_item})
sel.click(resources_form.add_button)
flash.assert_success_message('Catalog Bundle "{}" was added'.format(self.name))
def create(self):
domain = "ManageIQ (Locked)"
sel.force_navigate('catalog_item_new',
context={'provider_type': self.item_type})
sel.wait_for_element(basic_info_form.name_text)
fill(
basic_info_form, {
'name_text': self.name,
'description_text': self.description,
'display_checkbox': self.display_in,
'select_catalog': self.catalog,
'select_dialog': self.dialog
})
if self.item_type != "Orchestration":
sel.click(basic_info_form.field_entry_point)
dynamic_tree.click_path("Datastore", domain, "Service",
"Provisioning", "StateMachines",
"ServiceProvision_Template", "default")
sel.click(basic_info_form.apply_btn)
tabstrip.select_tab("Request Info")
template = template_select_form.template_table.find_row_by_cells({
'Name':
self.catalog_name,
'Provider':
self.provider
})
sel.click(template)
web_ui.fill(
request_form,
{
'instance_name': self.vm_name,
'instance_type': self.instance_type,
'guest_keypair': self.guest_keypair,
'availability_zone': self.availability_zone,
'cloud_tenant': self.cloud_tenant,
'cloud_network': self.cloud_network,
'security_groups':
self.security_groups[0], # not supporting multiselect now,
# just take first value
})
sel.click(template_select_form.add_button)
flash.assert_success_message('Service Catalog Item "%s" was added' %
self.name)
def test_containers_providers_default_view(button_group, view):
""" Containers Providers/Projects/Routes/Nodes/Containers/Replicators default view test
This test checks successful change of default views settings for Containers -->
Providers/Projects/Routes/Nodes/Containers/Replicators menu
Steps:
* Goes to Settings --> My Settings --> Default Views menu and change the default view
settings of Containers --> Containers Providers/Projects/Routes/Nodes
/Containers/Replicators
to Grid/Tile/List view
* Goes to Compute --> Containers --> Providers and verifies the selected view
"""
navigate_to(Server, 'MySettings')
tabs.select_tab("Default Views")
bg = ButtonGroup(button_group)
if not bg.active == str(view):
bg.choose(view)
sel.click(form_buttons.save)
navigate_to(mapping[button_group], 'All', use_resetter=False)
assert tb.is_active(view), "{}'s {} setting failed".format(view, button_group)
def systems(self):
"""Returns 'ConfigSystem' objects that are active under this profile"""
navigate_to(self, 'Details')
# ajax wait doesn't work here
_title_loc = "//span[contains(@id, 'explorer_title_text') " \
"and contains(normalize-space(text()), 'Configured Systems')]"
sel.wait_for_element(_title_loc)
# Unassigned config profile has no tabstrip
if "unassigned" not in self.name.lower():
tabs.select_tab("Configured Systems")
if sel.is_displayed(page.list_table_config_systems):
row_key = 'hostname'
return [
ConfigSystem(row[row_key].text, self)
for row in page.list_table_config_systems.rows()
]
return list()
def systems(self):
"""Returns 'ConfigSystem' objects that are active under this profile"""
self.navigate()
# ajax wait doesn't work here
_title_loc = version.pick({'5.4':
"//div[contains(@class, 'dhtmlxInfoBarLabel')"
" and contains(normalize-space(text()), 'Configured Systems')]",
'5.5': "//span[contains(@id, 'explorer_title_text')"
" and contains(normalize-space(text()), 'Configured Systems')]"})
sel.wait_for_element(_title_loc)
# Unassigned config profile has no tabstrip
if "unassigned" not in self.name.lower():
tabs.select_tab("Configured Systems")
if sel.is_displayed(page.list_table_config_systems):
row_key = version.pick({version.LOWEST: 'host name', '5.5': 'hostname'})
return [ConfigSystem(row[row_key].text, self) for row in
page.list_table_config_systems.rows()]
return list()
def create(self):
sel.force_navigate('catalog_item_new',
context={'provider_type': self.item_type})
sel.wait_for_element(basic_info_form.name_text)
catalog = fakeobject_or_object(self.catalog, "name", "<Unassigned>")
dialog = fakeobject_or_object(self.dialog, "name", "<No Dialog>")
fill(basic_info_form, {'name_text': self.name,
'description_text': self.description,
'display_checkbox': self.display_in,
'select_catalog': catalog.name,
'select_dialog': dialog.name,
'select_orch_template': self.orch_template,
'select_provider': self.provider_type,
'select_config_template': self.config_template})
if self.item_type != "Orchestration" and self.item_type != "AnsibleTower":
sel.click(basic_info_form.field_entry_point)
dynamic_tree.click_path("Datastore", self.domain, "Service", "Provisioning",
"StateMachines", "ServiceProvision_Template", "default")
sel.click(basic_info_form.apply_btn)
if self.catalog_name is not None and self.provisioning_data is not None:
tabstrip.select_tab("Request Info")
# Address BZ1321631
tabstrip.select_tab("Environment")
tabstrip.select_tab("Catalog")
template = template_select_form.template_table.find_row_by_cells({
'Name': self.catalog_name,
'Provider': self.provider
})
sel.click(template)
request_form.fill(self.provisioning_data)
sel.click(template_select_form.add_button)
def create(self):
view = navigate_to(self, 'BundleAdd')
domain = "ManageIQ (Locked)"
view.fill({'name': self.name,
'description': self.description,
'display': self.display_in,
'select_catalog': self.catalog.name,
'select_dialog': self.dialog})
if view.field_entry_point.value == "":
view.fill({'field_entry_point': ''})
view.tree.click_path(
"Datastore", domain, "Service", "Provisioning",
"StateMachines", "ServiceProvision_Template", "CatalogItemInitialization")
view.apply_button.click()
tabstrip.select_tab("Resources")
for cat_item in self.catalog_items:
view.fill({'select_resource': cat_item})
view.add_button.click()
view.flash.assert_success_message('Catalog Bundle "{}" was added'.format(self.name))
view = self.create_view(AllCatalogItemView)
assert view.is_displayed
view.flash.assert_no_error()
def queue(self, wait_for_finish=False):
navigate_to(self, 'Details')
toolbar.select("Queue")
flash.assert_no_errors()
tabstrip.select_tab("Saved Reports")
if wait_for_finish:
# Get the queued_at value to always target the correct row
queued_at = sel.text(list(records_table.rows())[0].queued_at)
def _get_state():
navigate_to(self, '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=1,
message="wait for report generation finished",
fail_func=toolbar.refresh(),
num_sec=300,
)
def create(self):
sel.force_navigate('catalog_item_new',
context={'provider_type': self.item_type})
fill(
basic_info_form, {
'name_text': self.name,
'description_text': self.description,
'display_checkbox': self.display_in,
'select_catalog': self.catalog,
'select_dialog': self.dialog
})
if (self.item_type is not "Generic"):
tabstrip.select_tab("Request Info")
template = template_select_form.template_table.find_row_by_cells({
'Name':
self.catalog_name,
'Provider':
self.provider
})
sel.click(template)
request_form.fill(self.provisioning_data)
sel.click(template_select_form.add_button)
flash.assert_success_message('Service Catalog Item "%s" was added' %
self.name)
def create(self):
domain = "ManageIQ (Locked)"
sel.force_navigate("catalog_item_new", context={"provider_type": self.item_type})
sel.wait_for_element(basic_info_form.name_text)
fill(
basic_info_form,
{
"name_text": self.name,
"description_text": self.description,
"display_checkbox": self.display_in,
"select_catalog": self.catalog,
"select_dialog": self.dialog,
},
)
if self.item_type != "Orchestration":
sel.click(basic_info_form.field_entry_point)
dynamic_tree.click_path(
"Datastore", domain, "Service", "Provisioning", "StateMachines", "ServiceProvision_Template", "default"
)
sel.click(basic_info_form.apply_btn)
tabstrip.select_tab("Request Info")
# Address BZ1321631
tabstrip.select_tab("Environment")
tabstrip.select_tab("Catalog")
template = template_select_form.template_table.find_row_by_cells(
{"Name": self.catalog_name, "Provider": self.provider}
)
sel.click(template)
web_ui.fill(
request_form,
{
"instance_name": self.vm_name,
"instance_type": self.instance_type,
"guest_keypair": self.guest_keypair,
"availability_zone": self.availability_zone,
"cloud_tenant": self.cloud_tenant,
"cloud_network": self.cloud_network,
"resource_groups": self.resource_group,
"virtual_private_cloud": self.virtual_private_cloud,
"cloud_subnet": self.cloud_subnet,
"security_groups": self.security_groups[0], # not supporting multiselect now,
# just take first value
},
)
sel.click(template_select_form.add_button)
flash.assert_success_message('Service Catalog Item "{}" was added'.format(self.name))
def create(self):
# Create has sequential forms, the first is only the provider type
navigate_to(self, 'Add')
sel.select("//select[@id='st_prov_type']",
self.provider_type or self.item_type or 'Generic')
sel.wait_for_element(basic_info_form.name_text)
catalog = fakeobject_or_object(self.catalog, "name", "Unassigned")
dialog = fakeobject_or_object(self.dialog, "name", "No Dialog")
fill(basic_info_form, {'name_text': self.name,
'description_text': self.description,
'display_checkbox': self.display_in,
'select_catalog': catalog.name,
'select_dialog': dialog.name,
'select_orch_template': self.orch_template,
'select_provider': self.provider_type,
'select_config_template': self.config_template})
if sel.text(basic_info_form.field_entry_point) == "":
sel.click(basic_info_form.field_entry_point)
if version.current_version() < "5.7":
dynamic_tree.click_path("Datastore", self.domain, "Service", "Provisioning",
"StateMachines", "ServiceProvision_Template", "default")
else:
entry_tree.click_path("Datastore", self.domain, "Service", "Provisioning",
"StateMachines", "ServiceProvision_Template", "default")
sel.click(basic_info_form.apply_btn)
if self.catalog_name is not None and self.provisioning_data is not None:
tabstrip.select_tab("Request Info")
# Address BZ1321631
tabstrip.select_tab("Environment")
tabstrip.select_tab("Catalog")
template = template_select_form.template_table.find_row_by_cells({
'Name': self.catalog_name,
# HACK to workaround BZ1390209
# revert back to Provider once it's fixed
'Deprecated' if BZ(1390209, forced_streams=["5.7", "upstream"]).blocks else
'Provider': self.provider
})
sel.click(template)
request_form.fill(self.provisioning_data)
sel.click(template_select_form.add_button)
def step(self, *args, **kwargs):
tabs.select_tab('Default Views')
"reports_all":
[
lambda ctx: accordion.tree("Reports", "All Reports"),
{
"report_add":
lambda ctx: cfg_btn("Add a new Report"),
}
],
"report_canned":
[
lambda ctx: accordion.tree("Reports", "All Reports", *ctx["path"]),
{
"report_canned_info":
[
lambda ctx: tabstrip.select_tab("Report Info"),
{
# Empty for now
},
],
"report_canned_saved": lambda ctx: tabstrip.select_tab("Saved Reports"),
}
],
"reports_custom":
lambda ctx: accordion.tree(
"Reports", "All Reports", "{} (All EVM Groups)".format(
db.get_yaml_config("vmdb")["server"]["company"]
), "Custom",
),
def reload_view():
"""Reloads and keeps on the current tabstrip page"""
current = tabstrip.get_selected_tab()
toolbar.select("Reload current display")
tabstrip.select_tab(current)
"reports_all":
[
lambda ctx: accordion.tree("Reports", "All Reports"),
{
"report_add":
lambda ctx: cfg_btn("Add a new Report"),
}
],
"report_canned":
[
lambda ctx: accordion.tree("Reports", "All Reports", *ctx["path"]),
{
"report_canned_info":
[
lambda ctx: tabstrip.select_tab("Report Info"),
{
# Empty for now
},
],
"report_canned_saved": lambda ctx: tabstrip.select_tab("Saved Reports"),
}
],
"reports_custom":
lambda ctx: accordion.tree(
"Reports", "All Reports", "{} (All EVM Groups)".format(
db.get_yaml_config("vmdb")["server"]["company"]
), "Custom",
),
def reload_view():
"""Reloads and keeps on the current tabstrip page"""
current = tabstrip.get_selected_tab()
toolbar.select("Reload current display")
tabstrip.select_tab(current)
lambda ctx: nav_edit(get_path(ctx['tree_item'])),
'automate_explorer_delete':
lambda _: cfg_btn('Remove selected Items',
invokes_alert=True)
}
],
'automate_explorer_namespace_new':
lambda _: cfg_btn('Add a New Namespace'),
'automate_explorer_class_new':
lambda _: cfg_btn('Add a New Class'),
'automate_explorer_method_edit':
lambda _: cfg_btn('Edit this Method'),
'automate_explorer_instance_edit':
lambda _: cfg_btn('Edit this Instance'),
'automate_explorer_methods': [
lambda _: select_tab('Methods'), {
'automate_explorer_method_new':
lambda _: cfg_btn('Add a New Method'),
'automate_explorer_method_table_select':
lambda ctx: table_select(ctx['table_item'].name)
}
],
'automate_explorer_instances': [
lambda _: select_tab('Instances'), {
'automate_explorer_instance_new':
lambda _: cfg_btn('Add a New Instance'),
'automate_explorer_instance_table_select':
lambda ctx: table_select(ctx['table_item'].name)
}
],
'automate_explorer_schema': [
def step(self):
tabs.select_tab("Visual")
{
'automate_explorer_table_select':
[lambda ctx: table_select(ctx['table_item'].name_in_table),
{
'automate_explorer_edit':
lambda context: context.tree_item.nav_edit(),
'automate_explorer_delete':
lambda _: cfg_btn('Remove selected Items', invokes_alert=True)}],
'automate_explorer_namespace_new': lambda _: cfg_btn('Add a New Namespace'),
'automate_explorer_domain_new': lambda _: cfg_btn('Add a New Domain'),
'automate_explorer_class_new': lambda _: cfg_btn('Add a New Class'),
"automate_explorer_domain_edit": lambda _: cfg_btn("Edit this Domain"),
'automate_explorer_method_edit': lambda _: cfg_btn('Edit this Method'),
'automate_explorer_instance_edit': lambda _: cfg_btn('Edit this Instance'),
'automate_explorer_methods': [lambda _: select_tab('Methods'),
{
'automate_explorer_method_new': lambda _: cfg_btn('Add a New Method'),
'automate_explorer_method_table_select':
lambda ctx: table_select(ctx['table_item'].name_in_table)}],
'automate_explorer_instances': [lambda _: select_tab('Instances'),
{
'automate_explorer_instance_new': lambda _: cfg_btn('Add a New Instance'),
'automate_explorer_instance_table_select':
lambda ctx: table_select(ctx['table_item'].name_in_table)}],
'automate_explorer_schema': [lambda _: select_tab("Schema"),
{
'automate_explorer_schema_edit': lambda _: cfg_btn("Edit selected Schema")
}]}],
def step(self):
accordion.tree(
"Reports", "All Reports", "{} (All EVM Groups)".format(
self.obj.appliance.company_name), "Custom",
self.obj.menu_name)
tabstrip.select_tab("Report Info")
def step(self):
tabstrip.select_tab("Saved Reports")
def step(self):
tabstrip.select_tab("Report Info")
def step(self):
tabstrip.select_tab("Saved Reports")
""" Module dealing with Configure/Tasks section.
"""
from cfme import web_ui as ui
import cfme.fixtures.pytest_selenium as sel
import cfme.web_ui.tabstrip as tabs
from cfme.web_ui import Form, Region, CheckboxTable, fill, paginator
from cfme.web_ui.menu import nav
from utils.timeutil import parsetime
from utils.wait import wait_for, TimedOutError
from utils.version import LOWEST
nav.add_branch("tasks",
dict(
tasks_my_vm=lambda _: tabs.select_tab("My VM Analysis Tasks"),
tasks_my_other_ui=lambda _: tabs.select_tab("My Other UI Tasks"),
tasks_all_vm=lambda _: tabs.select_tab("All VM Analysis Tasks"),
tasks_all_other=lambda _: tabs.select_tab("All Other Tasks"),
)
)
buttons = Region(
locators=dict(
default={LOWEST: "//*[@id='buttons_off']/li[3]/a/img",
'5.4': "//*[@id='buttons_off']/a"},
apply={LOWEST: "//*[@id='buttons_on']/li[1]/a/img",
'5.4': "//*[@id='buttons_on']/a[1]"},
reset={LOWEST: "//*[@id='buttons_on']/li[2]/a/img",
'5.4': "//*[@id='buttons_on']/a[2]"}
)
def step(self):
tabs.select_tab("Default Filters")
from utils.version import LOWEST, pick
get_tab_my = lambda: pick({
LOWEST: "My VM Analysis Tasks",
'5.6': "My VM and Container Analysis Tasks",
})
get_tab_all = lambda: pick({
LOWEST: "All VM Analysis Tasks",
'5.6': "All VM and Container Analysis Tasks",
})
nav.add_branch(
"tasks",
dict(
tasks_my_vm=lambda _: tabs.select_tab(get_tab_my()),
tasks_my_other_ui=lambda _: tabs.select_tab("My Other UI Tasks"),
tasks_all_vm=lambda _: tabs.select_tab(get_tab_all()),
tasks_all_other=lambda _: tabs.select_tab("All Other Tasks"),
))
buttons = Region(locators=dict(default={
LOWEST: "//*[@id='buttons_off']/li[3]/a/img",
'5.4': "//*[@id='buttons_off']/a"
},
apply={
LOWEST: "//*[@id='buttons_on']/li[1]/a/img",
'5.4': "//*[@id='buttons_on']/a[1]"
},
reset={
LOWEST: "//*[@id='buttons_on']/li[2]/a/img",
""" Module dealing with Configure/Tasks section.
Todo: Finish the rest of the things.
"""
import cfme.fixtures.pytest_selenium as sel
import cfme.web_ui.tabstrip as tabs
from cfme.web_ui import Form, Region, Select, CheckboxTable, fill, paginator
from cfme.web_ui.menu import nav
from utils.timeutil import parsetime
from utils.wait import wait_for, TimedOutError
nav.add_branch(
"tasks",
dict(
tasks_my_vm=lambda _: tabs.select_tab("My VM Analysis Tasks"),
tasks_my_other_ui=lambda _: tabs.select_tab("My Other UI Tasks"),
tasks_all_vm=lambda _: tabs.select_tab("All VM Analysis Tasks"),
tasks_all_other=lambda _: tabs.select_tab("All Other Tasks"),
))
buttons = Region(locators=dict(default="//*[@id='buttons_off']/li[3]/a/img",
apply="//*[@id='buttons_on']/li[1]/a/img",
reset="//*[@id='buttons_on']/li[2]/a/img"))
filter_form = Form(fields=[
("zone", Select("//select[@id='chosen_zone']")),
("user", Select("//select[@id='user_choice']")),
("time_period", Select("//select[@id='time_period']")),
("task_status_queued", "//input[@id='queued']"),
("task_status_running", "//input[@id='running']"),
cfg_btn = partial(toolbar.select, "Configuration")
nav.add_branch(
"reports",
{
"reports_all": [
lambda ctx: accordion.tree("Reports", "All Reports"), {
"report_add": lambda ctx: cfg_btn("Add a new Report"),
}
],
"report_canned": [
lambda ctx: accordion.tree("Reports", "All Reports", *ctx["path"]),
{
"report_canned_info": [
lambda ctx: tabstrip.select_tab("Report Info"),
{
# Empty for now
},
],
"report_canned_saved":
lambda ctx: tabstrip.select_tab("Saved Reports"),
}
],
"reports_custom":
lambda ctx: accordion.tree(
"Reports",
"All Reports",
"{} (All EVM Groups)".format(
db.get_yaml_config("vmdb")["server"]["company"]),
"Custom",
