def test_providers_summary(soft_assert, setup_a_provider):
"""Checks some informations about the provider. Does not check memory/frequency as there is
presence of units and rounding."""
path = ["Configuration Management", "Providers", "Providers Summary"]
report = CannedSavedReport.new(path)
for provider in report.data.rows:
if any(ptype in provider["MS Type"] for ptype in {"ec2", "openstack"}): # Skip cloud
continue
provider_fake_obj = Provider(name=provider["Name"])
sel.force_navigate("infrastructure_provider", context={"provider": provider_fake_obj})
hostname = version.pick({
version.LOWEST: ("Hostname", "Hostname"),
"5.5": ("Host Name", "Hostname")})
soft_assert(
provider_props(hostname[0]) == provider[hostname[1]],
"Hostname does not match at {}".format(provider["Name"]))
if version.current_version() < "5.4":
# In 5.4, hostname and IP address are shared under Hostname (above)
soft_assert(
provider_props("IP Address") == provider["IP Address"],
"IP Address does not match at {}".format(provider["Name"]))
soft_assert(
provider_props("Aggregate Host CPU Cores") == provider["Total Number of Logical CPUs"],
"Logical CPU count does not match at {}".format(provider["Name"]))
soft_assert(
provider_props("Aggregate Host CPUs") == provider["Total Number of Physical CPUs"],
"Physical CPU count does not match at {}".format(provider["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,
'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 test_grid_defaultview(request, setup_a_provider, key):
name = re.split(r"\/", key)
default_view = get_default_view(name[0])
set_grid_view(name[0])
sel.force_navigate(name[1])
assert tb.is_active('Grid View'), "Grid Default view setting failed"
reset_default_view(name[0], default_view)
def discover(rhevm=False, vmware=False, scvmm=False, cancel=False, start_ip=None, end_ip=None):
"""
Discover infrastructure providers. Note: only starts discovery, doesn't
wait for it to finish.
Args:
rhvem: Whether to scan for RHEVM providers
vmware: Whether to scan for VMware providers
scvmm: Whether to scan for SCVMM providers
cancel: Whether to cancel out of the discover UI.
"""
sel.force_navigate('infrastructure_provider_discover')
form_data = {}
if rhevm:
form_data.update({'rhevm_chk': True})
if vmware:
form_data.update({'vmware_chk': True})
if scvmm:
form_data.update({'scvmm_chk': True})
if start_ip:
for idx, octet in enumerate(start_ip.split('.')):
key = 'from_%i' % idx
form_data.update({key: octet})
if end_ip:
end_octet = end_ip.split('.')[-1]
form_data.update({'to_3': end_octet})
fill(discover_form, form_data,
action=form_buttons.cancel if cancel else discover_form.start_button,
action_always=True)
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 discover(rhevm=False, vmware=False, cancel=False, start_ip=None, end_ip=None):
"""
Discover infrastructure providers. Note: only starts discovery, doesn't
wait for it to finish.
Args:
rhvem: Whether to scan for RHEVM providers
vmware: Whether to scan for VMware providers
cancel: Whether to cancel out of the discover UI.
"""
sel.force_navigate('infrastructure_provider_discover')
if cancel: # normalize so that the form filler only clicks either start or cancel
cancel = True
else:
cancel = None
form_data = {'start_button': not cancel,
'cancel_button': cancel}
if rhevm:
form_data.update({'rhevm_chk': True})
if vmware:
form_data.update({'vmware_chk': True})
if start_ip:
for idx, octet in enumerate(start_ip.split('.')):
key = 'from_%i' % idx
form_data.update({key: octet})
if end_ip:
end_octet = end_ip.split('.')[-1]
form_data.update({'to_3': end_octet})
fill(discover_form, form_data)
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 validate(self):
""" Validates that the detail page matches the Providers information.
This method logs into the provider using the mgmt_system interface and collects
a set of statistics to be matched against the UI. The details page is then refreshed
continuously until the matching of all items is complete. A error will be raised
if the match is not complete within a certain defined time period.
"""
if not self._on_detail_page():
sel.force_navigate('infrastructure_provider', context={'provider': self})
stats_to_match = ['num_template', 'num_vm', 'num_datastore', 'num_host', 'num_cluster']
client = self.get_mgmt_system()
# Bail out here if the stats match.
if self._do_stats_match(client, stats_to_match):
client.disconnect()
return
refresh_timer = RefreshTimer()
# Otherwise refresh relationships and hand off to wait_for
tb.select("Configuration", "Refresh Relationships and Power States", invokes_alert=True)
sel.handle_alert()
ec, tc = wait_for(self._do_stats_match,
[client, stats_to_match, refresh_timer],
message="do_stats_match",
fail_func=sel.refresh,
num_sec=1000,
delay=10)
client.disconnect()
def exists(self):
sel.force_navigate('infrastructure_providers')
for page in paginator.pages():
if sel.is_displayed(Quadicon(self.name, 'infra_prov')):
return True
else:
return False
def edit_schema(self, add_fields=None, remove_fields=None):
sel.force_navigate("automate_explorer_schema_edit", context={'tree_item': self})
for remove_field in remove_fields or []:
f = remove_field.get_form()
fill(f, {}, action=f.remove_entry_button, action_always=True)
for add_field in add_fields or []:
sel.click(self.schema_edit_page.add_field_btn)
f = add_field.get_form(blank=True)
fill(f, {'name_text': add_field.name,
'type_select': add_field.type_,
'data_type_select': add_field.data_type,
'default_value_text': add_field.default_value,
'description_text': add_field.description,
'sub_cb': add_field.sub,
'collect_text': add_field.collect,
'message_text': add_field.message,
'on_entry_text': add_field.on_entry,
'on_exit_text': add_field.on_exit,
'max_retries_text': add_field.max_retries,
'max_time_text': add_field.max_time},
action=f.add_entry_button)
sel.click(form_buttons.save)
flash.assert_success_message('Schema for Automate Class "{}" was saved'.format(self.name))
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 test_appliance_replicate_database_disconnection_with_backlog(request, 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
provider.create()
stop_db_process(appl2.address)
sleep(60)
start_db_process(appl2.address)
sel.force_navigate("cfg_diagnostics_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 provider.exists
def exists(self):
try:
sel.force_navigate('automate_explorer_tree_path', context={'tree_item': self})
except exceptions.CandidateNotFound:
return False
else:
return True
def update(self, updates):
sel.force_navigate('catalog_item_edit',
context={'catalog': self.catalog, 'catalog_item': self})
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 "%s" was saved' % self.name)
def test_appliance_replicate_sync_role_change_with_backlog(request, provider):
"""Tests that a role change is replicated 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 disable DB sync role
provider.create()
conf.set_server_roles(database_synchronization=False)
sel.force_navigate("cfg_diagnostics_region_replication")
wait_for(lambda: conf.get_replication_status(navigate=False), fail_condition=True,
num_sec=360, delay=10, fail_func=sel.refresh, message="get_replication_status")
conf.set_server_roles(database_synchronization=True)
sel.force_navigate("cfg_diagnostics_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 provider.exists
def test_servicevmsandinstances_defaultfilters(setup_first_provider):
filters = [['Services', 'Workloads', 'VMs & Instances', 'Platform / Openstack']]
df = st.DefaultFilter(name='Platform / Openstack')
df.update({'filters': [(k, True) for k in filters]})
sel.force_navigate(
'service_vms_instances_filter_folder', context={'folder_name': 'Global Filters'})
assert sel.is_displayed_text(df.name), "Default Filter settings Failed!"
def test_list_defaultview(request, setup_a_provider, key):
name = re.split(r"\/", key)
default_view = get_default_view(name[0])
set_list_view(name[0])
sel.force_navigate(name[1])
assert tb.is_vms_list_view(), "List Default view setting failed"
reset_default_view(name[0], default_view)
def manage_folder(group, folder=None):
"""Context manager to use when modifying the folder contents.
Args:
group: User group.
folder: Which folder to manage. If None, top-level will be managed.
Returns: Context-managed :py:class:`cfme.intelligence.reports.ui_elements.FolderManager` inst.
"""
sel.force_navigate("report_menus_group", context={"group": group})
if folder is None:
reports_tree.click_path("Top Level")
else:
reports_tree.click_path("Top Level", folder)
try:
yield manager
except FolderManager._BailOut:
logger.info("Discarding editation modifications on {}".format(str(repr(manager))))
manager.discard()
except:
# In case of any exception, nothing will be saved
manager.discard()
raise # And reraise the exception
else:
# If no exception happens, save!
manager.commit()
form_buttons.save()
def test_servicetemplateandimages_defaultfilters(setup_first_provider):
filters = [['Services', 'Workloads', 'Templates & Images', 'Platform / Microsoft']]
df = st.DefaultFilter(name='Platform / Microsoft')
df.update({'filters': [(k, True) for k in filters]})
sel.force_navigate(
'service_templates_images_filter_folder', context={'folder_name': 'Global Filters'})
assert sel.is_displayed_text(df.name), "Default Filter settings Failed!"
def validate(self, db=True):
""" Validates that the detail page matches the Providers information.
This method logs into the provider using the mgmt_system interface and collects
a set of statistics to be matched against the UI. The details page is then refreshed
continuously until the matching of all items is complete. A error will be raised
if the match is not complete within a certain defined time period.
"""
client = self.get_mgmt_system()
# If we're not using db, make sure we are on the provider detail page
if not db:
sel.force_navigate('clouds_provider', context={'provider': self})
# Initial bullet check
if self._do_stats_match(client, self.STATS_TO_MATCH, db=db):
client.disconnect()
return
else:
# Set off a Refresh Relationships
sel.force_navigate('clouds_provider', context={'provider': self})
tb.select("Configuration", "Refresh Relationships and Power States", invokes_alert=True)
sel.handle_alert()
refresh_timer = RefreshTimer(time_for_refresh=300)
wait_for(self._do_stats_match,
[client, self.STATS_TO_MATCH, refresh_timer],
{'db': db},
message="do_stats_match_db",
num_sec=1000,
delay=60)
client.disconnect()
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
"""
sel.force_navigate('clouds_provider_policy_assignment', context={'provider': self})
return self._unassigned_policy_profiles
def edit_tags(self, tag, value):
sel.force_navigate('service_edit_tags',
context={'service_name': self.service_name})
fill(edit_tags_form, {'select_tag': tag,
'select_value': value},
action=form_buttons.save)
flash.assert_success_message('Tag edits were successfully saved')
def get_all_vms(do_not_navigate=False):
"""Returns list of all vms"""
if not do_not_navigate:
sel.force_navigate('infra_vms')
vms = set([])
# This is really stupid, but I cannot come up with better getting of the attributes :(
if not paginator.page_controls_exist():
for title in sel.elements(QUADICON_TITLE_LOCATOR):
title_value = sel.get_attribute(title, "title")
if not title_value:
title_value = sel.get_attribute(title, "data-original-title")
vms.add(title_value)
return vms
paginator.results_per_page(1000)
for page in paginator.pages():
try:
for page in paginator.pages():
for title in sel.elements(QUADICON_TITLE_LOCATOR):
title_value = sel.get_attribute(title, "title")
if not title_value:
title_value = sel.get_attribute(title, "data-original-title")
vms.add(title_value)
except sel.NoSuchElementException:
pass
return vms
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.
"""
sel.force_navigate("clouds_provider_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 set_grid_view(name):
bg = ButtonGroup(name)
sel.force_navigate("my_settings_default_views")
default_view = bg.active
if(default_view != 'Grid View'):
bg.choose('Grid View')
sel.click(form_buttons.save)
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
"""
sel.force_navigate("infrastructure_provider_policy_assignment", context={"provider": self})
return self._unassigned_policy_profiles
def test_data_integrity_for_topology(test_data):
""" This test verifies that every status box value under Containers Overview is identical to the
number present on its page.
Steps:
* Go to Containers / Overview
* All cells should contain the correct relevant information
# of nodes
# of providers
# ...
"""
section_values = {}
sel.force_navigate('container_dashboard')
# We should wait ~2 seconds for the StatusBox population
# (until we find a better solution)
time.sleep(2)
status_box = StatusBox(test_data[2])
section_values[test_data[0]] = int(status_box.value())
sel.force_navigate(test_data[1])
if section_values[test_data[0]] > 0:
if test_data[0] is Provider:
assert len(map(lambda i: i, Quadicon.all())) == section_values[test_data[0]]
else:
assert len(map(lambda r: r, test_data[3].rows())
) == section_values[test_data[0]]
else:
assert sel.is_displayed_text('No Records Found.')
def set_ownership(self, owner, group):
sel.force_navigate('service_set_ownership',
context={'service_name': self.service_name})
fill(set_ownership_form, {'select_owner': owner,
'select_group': group},
action=form_buttons.save)
flash.assert_success_message('Ownership saved for selected Service')
def test_provision_from_template(request, setup_provider, provider_crud, provisioning, vm_name):
""" Tests instance provision from template
Metadata:
test_flag: provision
"""
image = provisioning['image']['name']
note = ('Testing provisioning from image %s to vm %s on provider %s' %
(image, vm_name, provider_crud.key))
instance = instance_factory(vm_name, provider_crud, image)
request.addfinalizer(instance.delete_from_provider)
inst_args = {
'email': '*****@*****.**',
'first_name': 'Image',
'last_name': 'Provisioner',
'notes': note,
'instance_type': provisioning['instance_type'],
'availability_zone': provisioning['availability_zone'],
'security_groups': [provisioning['security_group']],
'guest_keypair': provisioning['guest_keypair']
}
if isinstance(provider_crud, OpenStackProvider):
inst_args['cloud_network'] = provisioning['cloud_network']
sel.force_navigate("clouds_instances_by_provider")
instance.create(**inst_args)
def check_vm_add(self, add_vm_name):
sel.force_navigate('service',
context={'service_name': self.service_name})
quadicon = Quadicon(add_vm_name, "vm")
sel.click(quadicon)
flash.assert_no_errors()
def infra_provider_quad(self):
sel.force_navigate("my_settings_visual")
return self.infra_provider_quad
def cloud_provider_quad(self):
sel.force_navigate("my_settings_visual")
return self.cloud_provider_quad
def template_quad(self, value):
sel.force_navigate("my_settings_visual")
fill(self.quadicons_form.template_quad, str(value))
sel.click(form_buttons.save)
def template_quad(self):
sel.force_navigate("my_settings_visual")
return self.template_quad
def vm_quad(self):
sel.force_navigate("my_settings_visual")
return self.vm_quad
def datastore_quad(self):
sel.force_navigate("my_settings_visual")
return self.datastore_quad
def infra_provider_quad(self, value):
sel.force_navigate("my_settings_visual")
fill(self.quadicons_form.infra_provider_quad, str(value))
sel.click(form_buttons.save)
def login_page(self):
sel.force_navigate("my_settings_visual")
return int(self.startpage_form.login_page.first_selected_option_text)
def report_view_limit(self):
sel.force_navigate("my_settings_visual")
return int(self.item_form.reports.first_selected_option_text)
def login_page(self, value):
sel.force_navigate("my_settings_visual")
fill(self.startpage_form.login_page, str(value))
sel.click(form_buttons.save)
def reset_default_view(name, default_view):
bg = ButtonGroup(name)
sel.force_navigate("my_settings_default_views")
if bg.active != default_view:
bg.choose(default_view)
sel.click(form_buttons.save)
def report_view_limit(self, value):
sel.force_navigate("my_settings_visual")
fill(self.item_form.reports, str(value))
sel.click(form_buttons.save)
def create(self, cancel=False):
sel.force_navigate("reports_widgets_rss_feed_add")
fill(self.form,
self.__dict__,
action=form_buttons.cancel if cancel else form_buttons.add)
flash.assert_no_errors()
def update(self, updates):
sel.force_navigate("reports_dashboard_edit",
context={"dashboard": self})
fill(self.form, updates, action=form_buttons.save)
flash.assert_no_errors()
def test_can_open_advanced_search():
sel.force_navigate("infra_vms")
search.ensure_advanced_search_open()
def update(self, updates):
sel.force_navigate("reports_widgets_rss_feed_edit",
context={"widget": self})
fill(self.form, updates, action=form_buttons.save)
flash.assert_no_errors()
def cleanup():
sel.force_navigate("infra_vms")
search.load_filter(filter_name)
search.delete_filter()
def go_to_detail(self):
if self.on_widget_page:
toolbar.select("Reload current display")
else:
sel.force_navigate(type(self).DETAIL_PAGE,
context={"widget": self})
def reset():
sel.force_navigate("clouds_images")
toolbar.select('List View')
def test_can_do_advanced_search():
sel.force_navigate("infra_vms")
assert search.is_advanced_search_possible(
), "Cannot do advanced search here!"
def set_grid():
sel.force_navigate("clouds_images")
toolbar.select('Grid View')
def reset_grid_stack():
sel.force_navigate("clouds_stacks")
toolbar.select('List View')
def tag(self, tag, **kwargs):
"""Tags the system by given tag"""
sel.force_navigate('infrastructure_host', context={'host': self})
mixins.add_tag(tag, **kwargs)
def set_grid_stack():
sel.force_navigate("clouds_stacks")
toolbar.select('Grid View')
def navigate(self):
return sel.force_navigate("saved_report_canned",
context={
"path": self.path,
"datetime": self.datetime
})
def untag(self, tag):
"""Removes the selected tag off the system"""
sel.force_navigate('infrastructure_host', context={'host': self})
mixins.remove_tag(tag)
def test_provision_with_additional_volume(request, setup_provider,
provisioning, provider, vm_name,
soft_assert, copy_domains, domain):
""" Tests provisioning with setting specific image from AE and then also making it create and
attach an additional 3G volume.
Metadata:
test_flag: provision, volumes
"""
image = provisioning['image']['name']
note = ('Testing provisioning from image %s to vm %s on provider %s' %
(image, vm_name, provider.key))
# Set up automate
cls = automate.Class(name="Methods",
namespace=automate.Namespace.make_path(
"Cloud",
"VM",
"Provisioning",
"StateMachines",
parent=domain))
method = automate.Method(name="openstack_CustomizeRequest", cls=cls)
try:
image_id = provider.mgmt.get_template_id(
provider.data["small_template"])
except KeyError:
pytest.skip("No small_template in provider adta!")
with update(method):
method.data = dedent('''\
$evm.root["miq_provision"].set_option(
:clone_options, {
:image_ref => nil,
:block_device_mapping_v2 => [{
:boot_index => 0,
:uuid => "%s",
:device_name => "vda",
:source_type => "image",
:destination_type => "volume",
:volume_size => 3,
:delete_on_termination => false
}]
}
)
''' % (image_id, ))
def _finish_method():
with update(method):
method.data = """prov = $evm.root["miq_provision"]"""
request.addfinalizer(_finish_method)
instance = Instance.factory(vm_name, provider, image)
request.addfinalizer(instance.delete_from_provider)
inst_args = {
'email': '*****@*****.**',
'first_name': 'Image',
'last_name': 'Provisioner',
'notes': note,
'instance_type': provisioning['instance_type'],
'availability_zone': provisioning['availability_zone'],
'security_groups': [provisioning['security_group']],
'guest_keypair': provisioning['guest_keypair']
}
if isinstance(provider, OpenStackProvider):
inst_args['cloud_network'] = provisioning['cloud_network']
sel.force_navigate("clouds_instances_by_provider")
instance.create(**inst_args)
prov_instance = provider.mgmt._find_instance_by_name(vm_name)
try:
assert hasattr(prov_instance, 'os-extended-volumes:volumes_attached')
volumes_attached = getattr(prov_instance,
'os-extended-volumes:volumes_attached')
assert len(volumes_attached) == 1
volume_id = volumes_attached[0]["id"]
assert provider.mgmt.volume_exists(volume_id)
volume = provider.mgmt.get_volume(volume_id)
assert volume.size == 3
finally:
instance.delete_from_provider()
wait_for(lambda: not instance.does_vm_exist_on_provider(),
num_sec=180,
delay=5)
if "volume_id" in locals(): # To handle the case of 1st or 2nd assert
if provider.mgmt.volume_exists(volume_id):
provider.mgmt.delete_volume(volume_id)
def power_off(self):
sel.force_navigate('infrastructure_host', context={'host': self})
pow_btn('Power Off')
sel.handle_alert()
def test_provision_with_boot_volume(request, setup_provider, provider,
provisioning, vm_name, soft_assert, domain,
copy_domains):
""" Tests provisioning from a template and attaching one booting volume.
Metadata:
test_flag: provision, volumes
"""
image = provisioning['image']['name']
note = ('Testing provisioning from image %s to vm %s on provider %s' %
(image, vm_name, provider.key))
with provider.mgmt.with_volume(
1, imageRef=provider.mgmt.get_template_id(image)) as volume:
# Set up automate
cls = automate.Class(name="Methods",
namespace=automate.Namespace.make_path(
"Cloud",
"VM",
"Provisioning",
"StateMachines",
parent=domain))
method = automate.Method(name="openstack_CustomizeRequest", cls=cls)
with update(method):
method.data = dedent('''\
$evm.root["miq_provision"].set_option(
:clone_options, {
:image_ref => nil,
:block_device_mapping_v2 => [{
:boot_index => 0,
:uuid => "%s",
:device_name => "vda",
:source_type => "volume",
:destination_type => "volume",
:delete_on_termination => false
}]
}
)
''' % (volume, ))
def _finish_method():
with update(method):
method.data = """prov = $evm.root["miq_provision"]"""
request.addfinalizer(_finish_method)
instance = Instance.factory(vm_name, provider, image)
request.addfinalizer(instance.delete_from_provider)
inst_args = {
'email': '*****@*****.**',
'first_name': 'Image',
'last_name': 'Provisioner',
'notes': note,
'instance_type': provisioning['instance_type'],
'availability_zone': provisioning['availability_zone'],
'security_groups': [provisioning['security_group']],
'guest_keypair': provisioning['guest_keypair']
}
if isinstance(provider, OpenStackProvider):
inst_args['cloud_network'] = provisioning['cloud_network']
sel.force_navigate("clouds_instances_by_provider")
instance.create(**inst_args)
soft_assert(vm_name in provider.mgmt.volume_attachments(volume))
soft_assert(provider.mgmt.volume_attachments(volume)[vm_name] == "vda")
instance.delete_from_provider(
) # To make it possible to delete the volume
wait_for(lambda: not instance.does_vm_exist_on_provider(),
num_sec=180,
delay=5)
def update(self, updates):
sel.force_navigate("report_custom_edit", context={"report": self})
fill(report_form, updates, action=form_buttons.save)
flash.assert_no_errors()
