test/automated-pytest-suite/testcases/functional/horizon/test_hosts.py
Yang Liu 33756ac899 Initial submission for starlingx pytest framework.
Include:
- util modules. such as table_parser, ssh/localhost clients, cli module,
exception, logger, etc. Util modules are mostly used by keywords.
- keywords modules. These are helper functions that are used directly by
test functions.
- platform (with platform or platform_sanity marker) and stx-openstack
(with sanity, sx_sanity, cpe_sanity, or storage_sanity marker) sanity
testcases
- pytest config conftest, and test fixture modules
- test config file template/example

Required packages:
- python3.4 or python3.5
- pytest >=3.10,<4.0
- pexpect
- requests
- pyyaml
- selenium (firefox, ffmpeg, pyvirtualdisplay, Xvfb or Xephyr or Xvnc)

Limitations:
- Anything that requires copying from Test File Server will not work until
a public share is configured to shared test files. Tests skipped for now.

Co-Authored-By: Maria Yousaf <maria.yousaf@windriver.com>
Co-Authored-By: Marvin Huang <marvin.huang@windriver.com>
Co-Authored-By: Yosief Gebremariam <yosief.gebremariam@windriver.com>
Co-Authored-By: Paul Warner <paul.warner@windriver.com>
Co-Authored-By: Xueguang Ma <Xueguang.Ma@windriver.com>
Co-Authored-By: Charles Chen <charles.chen@windriver.com>
Co-Authored-By: Daniel Graziano <Daniel.Graziano@windriver.com>
Co-Authored-By: Jordan Li <jordan.li@windriver.com>
Co-Authored-By: Nimalini Rasa <nimalini.rasa@windriver.com>
Co-Authored-By: Senthil Mukundakumar <senthil.mukundakumar@windriver.com>
Co-Authored-By: Anuejyan Manokeran <anujeyan.manokeran@windriver.com>
Co-Authored-By: Peng Peng <peng.peng@windriver.com>
Co-Authored-By: Chris Winnicki <chris.winnicki@windriver.com>
Co-Authored-By: Joe Vimar <Joe.Vimar@windriver.com>
Co-Authored-By: Alex Kozyrev <alex.kozyrev@windriver.com>
Co-Authored-By: Jack Ding <jack.ding@windriver.com>
Co-Authored-By: Ming Lei <ming.lei@windriver.com>
Co-Authored-By: Ankit Jain <ankit.jain@windriver.com>
Co-Authored-By: Eric Barrett <eric.barrett@windriver.com>
Co-Authored-By: William Jia <william.jia@windriver.com>
Co-Authored-By: Joseph Richard <Joseph.Richard@windriver.com>
Co-Authored-By: Aldo Mcfarlane <aldo.mcfarlane@windriver.com>

Story: 2005892
Task: 33750
Signed-off-by: Yang Liu <yang.liu@windriver.com>

Change-Id: I7a88a47e09733d39f024144530f5abb9aee8cad2
2019-07-15 15:30:00 -04:00

323 lines
13 KiB
Python
Executable File

#
# Copyright (c) 2019 Wind River Systems, Inc.
#
# SPDX-License-Identifier: Apache-2.0
#
import re
from pytest import fixture, mark
from consts import horizon
from utils import table_parser, cli
from utils.tis_log import LOG
from utils.horizon.pages.admin.platform import hostinventorypage
from keywords import system_helper
@fixture(scope='function')
def host_inventory_pg(admin_home_pg, request):
LOG.fixture_step('Go to Admin > Platform > Host Inventory')
host_inventory_pg = hostinventorypage.HostInventoryPage(
admin_home_pg.driver)
host_inventory_pg.go_to_target_page()
def teardown():
LOG.fixture_step('Back to Host Inventory page')
host_inventory_pg.go_to_target_page()
request.addfinalizer(teardown)
return host_inventory_pg
def format_uptime(uptime):
"""
Uptime displays in horizon may display like this format:
2 weeks, 10 hours
2 hours, 2 minutes
45 minutes
...
"""
uptime = int(uptime)
min_ = 60
hour = min_ * 60
day = hour * 24
week = day * 7
month = week * 4
uptime_months = uptime // month
uptime_weeks = uptime % month // week
uptime_days = uptime % month % week // day
uptime_hours = uptime % month % week % day // hour
uptime_mins = uptime % month % week % day % hour // min_
if uptime < min_:
return '0 minutes'
elif uptime < hour:
return '{} minute'.format(uptime_mins)
elif uptime < day:
return '{} hour, {} minute'.format(uptime_hours, uptime_mins)
elif uptime < week:
return '{} day, {} hour'.format(uptime_days, uptime_hours)
elif uptime < month:
return '{} week, {} day'.format(uptime_weeks, uptime_days)
elif uptime > week:
return '{} month'.format(uptime_months, uptime_weeks)
@mark.platform_sanity
def test_horizon_host_inventory_display(host_inventory_pg):
"""
Test the hosts inventory display:
Setups:
- Login as Admin
- Go to Admin > Platform > Host Inventory
Test Steps:
- Test host tables display
Teardown:
- Back to Host Inventory page
- Logout
"""
LOG.tc_step('Test host inventory display')
host_inventory_pg.go_to_hosts_tab()
host_list = system_helper.get_hosts()
for host_name in host_list:
LOG.info("Checking {}...".format(host_name))
headers_map = host_inventory_pg.hosts_table(
host_name).get_cli_horizon_mapping()
fields = list(headers_map.keys())
cli_values = system_helper.get_host_values(host_name, fields,
rtn_dict=True)
cli_values['uptime'] = format_uptime(cli_values['uptime'])
if cli_values.get('peers'):
cli_values['peers'] = cli_values.get('peers').get('name')
horizon_vals = host_inventory_pg.horizon_vals(host_name)
for cli_field in fields:
cli_val = cli_values[cli_field]
horizon_field = headers_map[cli_field]
horizon_val = horizon_vals[horizon_field]
if cli_field == 'uptime':
assert re.match(r'\d+ [dhm]', horizon_val)
else:
assert str(cli_val).lower() in horizon_val.lower(), \
'{} {} display incorrectly, expect: {} actual: {}'. \
format(host_name, horizon_field, cli_val, horizon_val)
horizon.test_result = True
@mark.parametrize('host_name', [
'controller-0'
])
def test_horizon_host_details_display(host_inventory_pg, host_name):
"""
Test the host details display:
Setups:
- Login as Admin
- Go to Admin > Platform > Host Inventory > Controller-0
Test Steps:
- Test host controller-0 overview display
- Test host controller-0 processor display
- Test host controller-0 memory display
- Test host controller-0 storage display
- Test host controller-0 ports display
- Test host controller-0 lldp display
Teardown:
- Logout
"""
host_table = host_inventory_pg.hosts_table(host_name)
host_details_pg = host_inventory_pg.go_to_host_detail_page(host_name)
# OVERVIEW TAB
LOG.tc_step('Test host: {} overview display'.format(host_name))
host_details_pg.go_to_overview_tab()
horizon_vals = host_details_pg.host_detail_overview(
host_table.driver).get_content()
fields_map = host_details_pg.host_detail_overview(
host_table.driver).OVERVIEW_INFO_HEADERS_MAP
cli_host_vals = system_helper.get_host_values(host_name, fields_map.keys(),
rtn_dict=True)
for field in fields_map:
horizon_header = fields_map[field]
cli_host_val = cli_host_vals[field]
horizon_val = horizon_vals.get(horizon_header)
if horizon_val is None:
horizon_val = 'None'
assert cli_host_val == horizon_val, '{} display incorrectly'.\
format(horizon_header)
else:
assert cli_host_val.upper() in horizon_val.upper(), \
'{} display incorrectly'.format(horizon_header)
LOG.info('Host: {} overview display correct'.format(host_name))
# PROCESSOR TAB
LOG.tc_step('Test host {} processor display'.format(host_name))
host_details_pg.go_to_processor_tab()
cpu_table = table_parser.table(
cli.system('host-cpu-list {}'.format(host_name))[1])
expt_cpu_info = {
'Processor Model:':
table_parser.get_values(cpu_table, 'processor_model')[0],
'Processors:': str(
len(set(table_parser.get_values(cpu_table, 'processor'))))}
horizon_cpu_info = host_details_pg.inventory_details_processor_info\
.get_content()
assert horizon_cpu_info['Processor Model:'] == expt_cpu_info[
'Processor Model:']
assert horizon_cpu_info['Processors:'] == expt_cpu_info['Processors:']
# MEMORY TABLE
LOG.tc_step('Test host {} memory display'.format(host_name))
checking_list = ['mem_total(MiB)', 'mem_avail(MiB)']
host_details_pg.go_to_memory_tab()
memory_table = table_parser.table(
cli.system('host-memory-list {}'.format(host_name))[1])
column_names = host_details_pg.memory_table.column_names
processor_list = table_parser.get_values(memory_table, column_names[0])
cli_memory_table_dict = table_parser.row_dict_table(memory_table,
column_names[0],
lower_case=False)
for processor in processor_list:
horizon_vm_pages_val = \
host_details_pg.get_memory_table_info(processor, column_names[2])
horizon_memory_val = \
host_details_pg.get_memory_table_info(processor, 'Memory')
if cli_memory_table_dict[processor]['hugepages(hp)_configured'] == \
'False':
assert horizon_vm_pages_val is None, \
'Horizon {} display incorrectly'.format(column_names[2])
else:
for field in checking_list:
assert cli_memory_table_dict[processor][field] in \
horizon_memory_val, 'Memory {} display incorrectly'
# STORAGE TABLE
# This test will loop each table and test their display
# Test may fail in following case:
# 1. disk table's Size header eg. Size(GiB) used different unit such as
# Size (MiB), Size (TiB)
# 2. lvg table may display different:
# Case 1: Name | State | Access | Size (GiB) | Avail Size(GiB) |
# Current Physical Volume - Current Logical Volumes
# Case 2: Name | State | Access | Size |
# Current Physical Volume - Current Logical Volumes
# Case 2 Size values in horizon are rounded by 2 digits but in CLI not
# rounded
LOG.tc_step('Test host {} storage display'.format(host_name))
host_details_pg.go_to_storage_tab()
cmd_list = ['host-disk-list {}'.format(host_name),
'host-disk-partition-list {}'.format(host_name),
'host-lvg-list {}'.format(host_name),
'host-pv-list {}'.format(host_name)]
table_names = ['disk table', 'disk partition table',
'local volume groups table', 'physical volumes table']
horizon_storage_tables = [host_details_pg.storage_disks_table,
host_details_pg.storage_partitions_table,
host_details_pg.storage_lvg_table,
host_details_pg.storage_pv_table]
cli_storage_tables = []
for cmd in cmd_list:
cli_storage_tables.append(table_parser.table(cli.system(cmd))[1])
for i in range(len(horizon_storage_tables)):
horizon_table = horizon_storage_tables[i]
unique_key = horizon_table.column_names[0]
horizon_row_dict_table = host_details_pg.get_horizon_row_dict(
horizon_table, key_header_index=0)
cli_table = cli_storage_tables[i]
table_dict_unique_key = list(horizon_table.HEADERS_MAP.keys())[
list(horizon_table.HEADERS_MAP.values()).index(unique_key)]
cli_row_dict_storage_table = \
table_parser.row_dict_table(cli_table,
table_dict_unique_key,
lower_case=False)
for key_header in horizon_row_dict_table:
for cli_header in horizon_table.HEADERS_MAP:
horizon_header = horizon_table.HEADERS_MAP[cli_header]
horizon_row_dict = horizon_row_dict_table[key_header]
cli_row_dict = cli_row_dict_storage_table[key_header]
# Solve parser issue: e.g. Size (GiB)' should be '558.029'
# not ['5589.', '029']
cli_val = cli_row_dict[cli_header]
if isinstance(cli_val, list):
cli_row_dict[cli_header] = ''.join(cli_val)
assert horizon_row_dict[horizon_header] == cli_row_dict[
cli_header], \
'In {}: disk: {} {} display incorrectly'.format(
table_names[i], key_header, horizon_header)
LOG.info('{} display correct'.format(table_names[i]))
# PORT TABLE
LOG.tc_step('Test host {} port display'.format(host_name))
host_details_pg.go_to_ports_tab()
horizon_port_table = host_details_pg.ports_table()
cli_port_table = table_parser.table(
cli.system('host-ethernet-port-list {}'.format(host_name))[1])
horizon_row_dict_port_table = host_details_pg.get_horizon_row_dict(
horizon_port_table, key_header_index=0)
cli_row_dict_port_table = table_parser.row_dict_table(cli_port_table,
'name',
lower_case=False)
for ethernet_name in cli_row_dict_port_table:
for cli_header in horizon_port_table.HEADERS_MAP:
horizon_header = horizon_port_table.HEADERS_MAP[cli_header]
horizon_row_dict = horizon_row_dict_port_table[ethernet_name]
cli_row_dict = cli_row_dict_port_table[ethernet_name]
if cli_header not in cli_row_dict and cli_header == 'mac address':
cli_val = cli_row_dict['macaddress']
else:
cli_val = cli_row_dict[cli_header]
horizon_val = horizon_row_dict[horizon_header]
# Solve table parser issue: MAC Address returns list eg: [
# 'a4:bf:01:35:4a:', '32']
if isinstance(cli_val, list):
cli_val = ''.join(cli_val)
assert cli_val in horizon_val, '{} display incorrectly'.format(
horizon_header)
# LLDP TABLE
LOG.tc_step('Test host {} lldp display'.format(host_name))
host_details_pg.go_to_lldp_tab()
lldp_list_table = table_parser.table(
cli.system('host-lldp-neighbor-list {}'.format(host_name))[1])
lldp_uuid_list = table_parser.get_values(lldp_list_table, 'uuid')
horizon_lldp_table = host_details_pg.lldp_table()
cli_row_dict_lldp_table = {}
horizon_row_dict_lldp_table = host_details_pg.get_horizon_row_dict(
horizon_lldp_table, key_header_index=1)
for uuid in lldp_uuid_list:
cli_row_dict = {}
lldp_show_table = table_parser.table(
cli.system('lldp-neighbor-show {}'.format(uuid))[1])
row_dict_key = table_parser.get_value_two_col_table(lldp_show_table,
'port_identifier')
for cli_header in horizon_lldp_table.HEADERS_MAP:
horizon_header = horizon_lldp_table.HEADERS_MAP[cli_header]
horizon_row_dict = horizon_row_dict_lldp_table[row_dict_key]
cli_row_dict[cli_header] = table_parser.get_value_two_col_table(
lldp_show_table, cli_header)
cli_row_dict_lldp_table[row_dict_key] = cli_row_dict
assert cli_row_dict[cli_header] == \
horizon_row_dict[horizon_header], \
'lldp neighbor:{} {} display incorrectly'.\
format(row_dict_key, horizon_header)
horizon.test_result = True