def list_data_table(self, raw=False):
"""Returns list of data from table"""
self.load_chart_reference()
data = []
if self.has_warning:
return data
table = Table(table_locator="//table[contains(@class, 'table')]")
headers = []
for header in table.headers:
headers.append(attributize_string(sel.text_sane(header)))
for row in table.rows():
_data = {}
for header in headers:
if header == "datetime":
_datetime = sel.text_sane(row[header])
if raw:
_data[header] = _datetime
else:
# sample 10/19/16 15:23:38 UTC
_data['timestamp'] = self._timestamp(
datetime.strptime(_datetime,
"%m/%d/%y %H:%M:%S %Z"))
else:
_value = round_double(value_of(sel.text_sane(row[header])))
_data[header] = None if _value == '' else _value
data.append(_data)
return data
def list_data_table(self, raw=False):
"""Returns list of data from table"""
self.load_chart_reference()
data = []
if self.has_warning:
return data
table = Table(table_locator="//table[contains(@class, 'table')]")
headers = []
for header in table.headers:
headers.append(attributize_string(sel.text_sane(header)))
for row in table.rows():
_data = {}
for header in headers:
if header == "datetime":
_datetime = sel.text_sane(row[header])
if raw:
_data[header] = _datetime
else:
# sample 10/19/16 15:23:38 UTC
_data['timestamp'] = self._timestamp(
datetime.strptime(_datetime, "%m/%d/%y %H:%M:%S %Z"))
else:
_value = round_double(value_of(sel.text_sane(row[header])))
_data[header] = None if _value == '' else _value
data.append(_data)
return data
def load(self):
self._raw_keys = []
self._keys = []
key_values = []
if sel.is_displayed(self.MULTIKEY_LOC, root=self._entry):
# WE cannot process this kind of table yet.
return
for row in sel.elements(self.ROWS, root=self._entry):
tds = sel.elements('./td', root=row)
key = tds[0]
klass = sel.get_attribute(key, 'class')
if klass and 'label' in klass:
# Ordinary field
key_id = attributize_string(sel.text_sane(key))
value = tuple(tds[1:])
try:
rowspan = int(sel.get_attribute(key, 'rowspan'))
except (ValueError, TypeError):
rowspan = None
if rowspan:
key_values.append((key, key_id, [value]))
else:
key_values.append((key, key_id, value))
else:
# value of last key_values should be extended
key_values[-1][2].append(tuple(tds))
for key, key_id, value in key_values:
value_object = process_field(value)
setattr(self, key_id, value_object)
self._raw_keys.append(sel.text_sane(key))
self._keys.append(key_id)
def load(self):
self._raw_keys = []
self._keys = []
key_values = []
if sel.is_displayed(self.MULTIKEY_LOC, root=self._entry):
# WE cannot process this kind of table yet.
return
for row in sel.elements(self.ROWS, root=self._entry):
tds = sel.elements('./td', root=row)
key = tds[0]
klass = sel.get_attribute(key, 'class')
if klass and 'label' in klass:
# Ordinary field
key_id = attributize_string(sel.text_sane(key))
value = tuple(tds[1:])
try:
rowspan = int(sel.get_attribute(key, 'rowspan'))
except (ValueError, TypeError):
rowspan = None
if rowspan:
key_values.append((key, key_id, [value]))
else:
key_values.append((key, key_id, value))
else:
# value of last key_values should be extended
key_values[-1][2].append(tuple(tds))
for key, key_id, value in key_values:
value_object = process_field(value)
setattr(self, key_id, value_object)
self._raw_keys.append(sel.text_sane(key))
self._keys.append(key_id)
def is_on_chart_page(self):
"""Returns True we we are in detailed chart page, otherwise False"""
if len(sel.text_sane(sel.elements(CHARTS))) == 0:
return False
if sel.text_sane(sel.element(CHARTS).find_element_by_tag_name('h2')) == self.name \
and len(sel.elements(
"//table[contains(@class, 'table')]//th[normalize-space(.)='Date/Time']")) == 1:
return True
return False
def is_on_chart_page(self):
"""Returns True we we are in detailed chart page, otherwise False"""
if len(sel.text_sane(sel.elements(CHARTS))) == 0:
return False
if sel.text_sane(sel.element(CHARTS).find_element_by_tag_name('h2')) == self.name \
and len(sel.elements(
"//table[contains(@class, 'table')]//th[normalize-space(.)='Date/Time']")) == 1:
return True
return False
def all():
"""Returns all of the file shares available"""
sel.force_navigate("volumes")
for page in paginator.pages():
for row in list_page.volumes_table.rows():
yield Volume(name=sel.text_sane(row.name),
element_name=sel.text_sane(row.element_name),
vms=int(sel.text_sane(row.vms)),
hosts=int(sel.text_sane(row.hosts)),
datastores=int(sel.text_sane(row.datastores)),
health_status=sel.text_sane(row.health_status),
op_status=sel.text_sane(row.operational_status),
description=sel.text_sane(row.description),
region=sel.text_sane(row.region),
last_upd_status=sel.text_sane(row.last_update_status))
def _reload(self):
self._legends = []
self._elements = []
self._lines = []
self.search_box = TopologySearchBox()
self.display_names = TopologyDisplayNames()
# load elements
# we have to wait few seconds, initial few seconds elements are moving
if len(sel.elements(self.ELEMENTS)) > 0:
self._el_ref = TopologyElement(o=self, element=sel.elements(self.ELEMENTS)[-1])
wait_for(lambda: self._is_el_movement_stopped(), delay=2, num_sec=30)
for element in sel.elements(self.ELEMENTS):
self._elements.append(TopologyElement(o=self, element=element))
# load lines
for line in sel.elements(self.LINES):
self._lines.append(TopologyLine(element=line))
# load legends
# remove old legends
for legend_id in self._legends:
try:
delattr(self, legend_id)
except AttributeError:
pass
# load available legends
for legend in sel.elements(self.LEGENDS):
legend_text = sel.text_sane(legend.find_element_by_tag_name('label'))
legend_id = attributize_string(legend_text.strip())
legend_object = TopologyLegend(name=legend_text, element=legend)
setattr(self, legend_id, legend_object)
self._legends.append(legend_id)
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 row_by_name(self, name):
for row in self.rows:
row_name = sel.text_sane(sel.element("./td[1]", root=row))
if row_name == name:
return row
else:
raise NameError("Did not find row named {}!".format(name))
def test_breadcrumbs(provider, soft_assert):
for dataset in DATA_SETS:
if current_version() < '5.7' and dataset.obj == Template:
continue
rows = navigate_and_get_rows(provider, dataset.obj, 1)
if not rows:
pytest.skip(
'Could not test breadcrums: No records found in {}\'s table'.
format(dataset.obj.__name__))
row = rows[-1]
instance_name = row[2].text
sel.click(row)
breadcrumb_elements = breadcrumbs()
soft_assert(
breadcrumb_elements,
'Breadcrumbs not found in {} {} summary page'.format(
dataset.obj.__name__, instance_name))
bread_names_2_element = {
sel.text_sane(b): b
for b in breadcrumb_elements
}
try:
breadcrumb_element = soft_get(bread_names_2_element,
dataset.obj_base_name,
dict_=True)
except:
soft_assert(
False,
'Could not find breadcrumb "{}" in {} {} summary page. breadcrumbs: {}'
.format(dataset.obj_base_name, bread_names_2_element.keys(),
dataset.obj.__name__, instance_name))
breadcrumb_name = sel.text_sane(breadcrumb_element)
sel.click(breadcrumb_element)
# We verify the location as following since we want to prevent from name convention errors
soft_assert(
dataset.obj_base_name in summary_title().lower(),
'Breadcrumb link "{}" in {} {} page should navigate to '
'{}s main page. navigated instead to: {}'.format(
breadcrumb_name, dataset.obj.__name__, instance_name,
dataset.obj.__name__, sel.current_url()))
def all():
"""Returns all of the file shares available"""
sel.force_navigate("volumes")
for page in paginator.pages():
for row in list_page.volumes_table.rows():
yield Volume(
name=sel.text_sane(row.name),
element_name=sel.text_sane(row.element_name),
vms=int(sel.text_sane(row.vms)),
hosts=int(sel.text_sane(row.hosts)),
datastores=int(sel.text_sane(row.datastores)),
health_status=sel.text_sane(row.health_status),
op_status=sel.text_sane(row.operational_status),
description=sel.text_sane(row.description),
region=sel.text_sane(row.region),
last_upd_status=sel.text_sane(row.last_update_status)
)
def load_chart_reference(self, force_reload=False):
"""Takes current page to chart detailed page"""
if self.is_on_chart_page and not force_reload:
return
if not self.is_on_chart_page:
self._utz_object.reload()
self._c_object = None
if not self.is_on_chart_page:
root_objs = sel.elements(CHARTS)
for root_obj in root_objs:
if sel.text_sane(
root_obj.find_element_by_tag_name('h2')) == self.name:
root_obj.find_element_by_tag_name("a").click()
sel.wait_for_ajax()
self._c_object = sel.element(CHARTS)
break
else:
self._c_object = sel.element(CHARTS)
if self._c_object is None:
raise RuntimeError("Unable to get detail page of '{}'".format(
self.name))
# remove old legends and load new legends
for legend_id in self._legends:
try:
delattr(self, legend_id)
except AttributeError:
pass
self._legends = []
# load available legends
for legend in sel.elements(self.LEGENDS):
legend_text = sel.text_sane(legend)
# changing legend name to full name with pre defined map
legend_id = self._get_ui_key(
attributize_string(legend_text.strip()))
legend_object = Legend(name=legend_text, legend_object=legend)
setattr(self, legend_id, legend_object)
self._legends.append(legend_id)
self._c_lines = self._c_object\
.find_elements_by_xpath("//*[name()='g']//*[contains(@class, 'c3-target') "
"and contains(@class, 'c3-chart-line')]")
def test_breadcrumbs(provider, soft_assert):
for dataset in DATA_SETS:
if current_version() < '5.7' and dataset.obj == Template:
continue
rows = navigate_and_get_rows(provider, dataset.obj, 1)
if not rows:
pytest.skip('Could not test breadcrums: No records found in {}\'s table'
.format(dataset.obj.__name__))
row = rows[-1]
instance_name = row[2].text
sel.click(row)
breadcrumb_elements = breadcrumbs()
soft_assert(breadcrumb_elements,
'Breadcrumbs not found in {} {} summary page'
.format(dataset.obj.__name__, instance_name))
bread_names_2_element = {sel.text_sane(b): b for b in breadcrumb_elements}
try:
breadcrumb_element = soft_get(bread_names_2_element,
dataset.obj_base_name, dict_=True)
except:
soft_assert(False,
'Could not find breadcrumb "{}" in {} {} summary page. breadcrumbs: {}'
.format(dataset.obj_base_name, bread_names_2_element.keys(),
dataset.obj.__name__, instance_name))
breadcrumb_name = sel.text_sane(breadcrumb_element)
sel.click(breadcrumb_element)
# We verify the location as following since we want to prevent from name convention errors
soft_assert(dataset.obj_base_name in summary_title().lower(),
'Breadcrumb link "{}" in {} {} page should navigate to '
'{}s main page. navigated instead to: {}'
.format(breadcrumb_name, dataset.obj.__name__,
instance_name, dataset.obj.__name__,
sel.current_url()))
def reload(self):
for key in self._keys:
try:
delattr(self, key)
except AttributeError:
pass
self._keys = []
self._object.load_details(refresh=True)
for header in sel.elements(self.HEADERS):
header_text = sel.text_sane(header)
header_id = attributize_string(header_text)
table_object = SummaryTable(self._object, header_text, header)
setattr(self, header_id, table_object)
self._keys.append(header_id)
def reload(self):
for key in self._keys:
try:
delattr(self, key)
except AttributeError:
pass
self._keys = []
self._object.load_details(refresh=True)
for header in sel.elements(self.HEADERS):
header_text = sel.text_sane(header)
header_id = attributize_string(header_text)
table_object = SummaryTable(self._object, header_text, header)
setattr(self, header_id, table_object)
self._keys.append(header_id)
def load_chart_reference(self, force_reload=False):
"""Takes current page to chart detailed page"""
if self.is_on_chart_page and not force_reload:
return
if not self.is_on_chart_page:
self._utz_object.reload()
self._c_object = None
if not self.is_on_chart_page:
root_objs = sel.elements(CHARTS)
for root_obj in root_objs:
if sel.text_sane(root_obj.find_element_by_tag_name('h2')) == self.name:
root_obj.find_element_by_tag_name("a").click()
sel.wait_for_ajax()
self._c_object = sel.element(CHARTS)
break
else:
self._c_object = sel.element(CHARTS)
if self._c_object is None:
raise RuntimeError("Unable to get detail page of '{}'".format(self.name))
# remove old legends and load new legends
for legend_id in self._legends:
try:
delattr(self, legend_id)
except AttributeError:
pass
self._legends = []
# load available legends
for legend in sel.elements(self.LEGENDS):
legend_text = sel.text_sane(legend)
# changing legend name to full name with pre defined map
legend_id = self._get_ui_key(attributize_string(legend_text.strip()))
legend_object = Legend(name=legend_text, legend_object=legend)
setattr(self, legend_id, legend_object)
self._legends.append(legend_id)
self._c_lines = self._c_object\
.find_elements_by_xpath("//*[name()='g']//*[contains(@class, 'c3-target') "
"and contains(@class, 'c3-chart-line')]")
def _reload(self, force_reload=False):
if not force_reload and len(self._charts) > 0:
return
# remove old charts
for chart_id in self._charts:
try:
delattr(self, chart_id)
except AttributeError:
pass
self._charts = []
# load available charts
for chart in sel.elements(CHARTS):
chart_text = sel.text_sane(chart.find_element_by_class_name('card-pf-title'))
chart_id = attributize_string(chart_text.strip())
chart_object = LineChart(chart_id=chart_id, name=chart_text, utilization_object=self)
setattr(self, chart_id, chart_object)
self._charts.append(chart_id)
def _reload(self, force_reload=False):
if not force_reload and len(self._charts) > 0:
return
# remove old charts
for chart_id in self._charts:
try:
delattr(self, chart_id)
except AttributeError:
pass
self._charts = []
# load available charts
for chart in sel.elements(CHARTS):
chart_text = sel.text_sane(chart.find_element_by_class_name('card-pf-title'))
chart_id = attributize_string(chart_text.strip())
chart_object = LineChart(chart_id=chart_id, name=chart_text, utilization_object=self)
setattr(self, chart_id, chart_object)
self._charts.append(chart_id)
def _reload(self):
self._legends = []
self.search_box = TopologySearchBox()
self.display_names = TopologyDisplayNames()
# load elements
# we have to wait few seconds, initial few seconds elements are moving
self.reload_elements()
# load legends
# remove old legends
for legend_id in self._legends:
try:
delattr(self, legend_id)
except AttributeError:
pass
# load available legends
for legend in sel.elements(self.LEGENDS):
legend_text = sel.text_sane(legend.find_element_by_tag_name('label'))
legend_id = attributize_string(legend_text.strip())
legend_object = TopologyLegend(name=legend_text, element=legend)
setattr(self, legend_id, legend_object)
self._legends.append(legend_id)
def get_workers_list(do_not_navigate=False, refresh=True):
"""Retrieves all workers.
Returns a dictionary where keys are names of the workers and values are lists (because worker
can have multiple instances) which contain dictionaries with some columns.
"""
if do_not_navigate:
if refresh:
tb.select("Reload current workers display")
else:
navigate_to(current_appliance.server, 'Workers')
workers = {}
for row in records_table.rows():
name = sel.text_sane(row.name)
if name not in workers:
workers[name] = []
worker = {
"status":
sel.text_sane(row.status),
"pid":
int(sel.text_sane(row.pid))
if len(sel.text_sane(row.pid)) > 0 else None,
"spid":
int(sel.text_sane(row.spid))
if len(sel.text_sane(row.spid)) > 0 else None,
"started":
parsetime.from_american_with_utc(sel.text_sane(row.started)),
"last_heartbeat":
None,
}
try:
workers["last_heartbeat"] = parsetime.from_american_with_utc(
sel.text_sane(row.last_heartbeat))
except ValueError:
pass
workers[name].append(worker)
return workers
def _reload(self):
self._legends = []
self.search_box = TopologySearchBox()
self.display_names = TopologyDisplayNames()
# load elements
# we have to wait few seconds, initial few seconds elements are moving
self.reload_elements()
# load legends
# remove old legends
for legend_id in self._legends:
try:
delattr(self, legend_id)
except AttributeError:
pass
# load available legends
for legend in sel.elements(self.LEGENDS):
legend_text = sel.text_sane(
legend.find_element_by_tag_name('label'))
legend_id = attributize_string(legend_text.strip())
legend_object = TopologyLegend(name=legend_text, element=legend)
setattr(self, legend_id, legend_object)
self._legends.append(legend_id)
def text_value(self):
return sel.text_sane(self._el)
def text_value(self):
return sel.text_sane(self._el)
def load(self):
self._raw_keys = []
self._keys = []
key_values = []
if sel.is_displayed(self.MULTIKEY_LOC, root=self._entry):
logger.warning(
"Parent SummaryTable created for {table_name}, "
"it might create few un-initialized SummaryTable".format(
table_name=self._text))
self._multitable = True
# get all table rows (include titles)
table_rows = sel.elements(self.ROWS, root=self._entry)
# parsing table titles
table_titles = sel.elements('./td', root=table_rows[0])
table_titles_text = [
el.text.replace(" ", "_") for el in table_titles
]
# match each line values with the relevant title
for row in table_rows[1:]:
# creating mapping between title and row values
row_mapping = dict(
zip(table_titles_text,
[el.text for el in sel.elements('./td', root=row)]))
# set the value of the "name" column to be the key of the entire table,
# if "name" is not available setting the most left element to be the key
row_key = row_mapping.get("Name", row_mapping.keys()[0])
# creating empty table to populate the row data as regular table
table = SummaryTable(self._object,
row_key,
row,
skip_load=True)
# set the keys of the table to table object
table._keys = row_mapping.keys()
# add attr for each key
for key in row_mapping.keys():
setattr(table, key, row_mapping[key])
# add the entire table to parent table keys
self._keys.append(row_key)
# add attr to parent table
setattr(self, row_key, table)
return
for row in sel.elements(self.ROWS, root=self._entry):
tds = sel.elements('./td', root=row)
key = tds[0]
klass = sel.get_attribute(key, 'class')
if klass and 'label' in klass:
# Ordinary field
key_id = attributize_string(sel.text_sane(key))
value = tuple(tds[1:])
try:
rowspan = int(sel.get_attribute(key, 'rowspan'))
except (ValueError, TypeError):
rowspan = None
if rowspan:
key_values.append((key, key_id, [value]))
else:
key_values.append((key, key_id, value))
else:
# value of last key_values should be extended
key_values[-1][2].append(tuple(tds))
for key, key_id, value in key_values:
value_object = process_field(value)
setattr(self, key_id, value_object)
self._raw_keys.append(sel.text_sane(key))
self._keys.append(key_id)
def load(self):
self._raw_keys = []
self._keys = []
key_values = []
if sel.is_displayed(self.MULTIKEY_LOC, root=self._entry):
logger.warning(
"Parent SummaryTable created for {table_name}, "
"it might create few un-initialized SummaryTable".format(
table_name=self._text))
self._multitable = True
# get all table rows (include titles)
table_rows = sel.elements(self.ROWS, root=self._entry)
# parsing table titles
table_titles = sel.elements('./td', root=table_rows[0])
table_titles_text = [el.text.replace(" ", "_") for el in table_titles]
# match each line values with the relevant title
for row in table_rows[1:]:
# creating mapping between title and row values
row_mapping = dict(zip(table_titles_text,
[el.text for el in sel.elements('./td', root=row)]))
# set the value of the "name" column to be the key of the entire table,
# if "name" is not available setting the most left element to be the key
row_key = row_mapping.get("Name", row_mapping.keys()[0])
# creating empty table to populate the row data as regular table
table = SummaryTable(self._object,
row_key,
row, skip_load=True)
# set the keys of the table to table object
table._keys = row_mapping.keys()
# add attr for each key
for key in row_mapping.keys():
setattr(table, key, row_mapping[key])
# add the entire table to parent table keys
self._keys.append(row_key)
# add attr to parent table
setattr(self, row_key, table)
return
for row in sel.elements(self.ROWS, root=self._entry):
tds = sel.elements('./td', root=row)
key = tds[0]
klass = sel.get_attribute(key, 'class')
if klass and 'label' in klass:
# Ordinary field
key_id = attributize_string(sel.text_sane(key))
value = tuple(tds[1:])
try:
rowspan = int(sel.get_attribute(key, 'rowspan'))
except (ValueError, TypeError):
rowspan = None
if rowspan:
key_values.append((key, key_id, [value]))
else:
key_values.append((key, key_id, value))
else:
# value of last key_values should be extended
key_values[-1][2].append(tuple(tds))
for key, key_id, value in key_values:
value_object = process_field(value)
setattr(self, key_id, value_object)
self._raw_keys.append(sel.text_sane(key))
self._keys.append(key_id)
