def global_vars_and_constants_init():
global tf_rest_data
global vars
vars = st.ensure_min_topology('D1')
tf_rest_data = SpyTestDict()
hw_constants = st.get_datastore(vars.D1, "constants")
tf_rest_data.all_ports = intapi.get_all_interfaces(vars.D1,
int_type='physical')
# Global Vars
tf_rest_data.platform = bcapi.get_hwsku(vars.D1)
tf_rest_data.show_version = bcapi.show_version(vars.D1)
tf_rest_data.feature = "bst"
tf_rest_data.configure_bst_thresholds = "configure-bst-thresholds"
tf_rest_data.configure_bst_multi_thresholds = "configure-bst-multi-thresholds"
tf_rest_data.get_bst_thresholds = "get-bst-thresholds"
tf_rest_data.clear_bst_thresholds = "clear-bst-thresholds"
tf_rest_data.queues_to_check = [
'COUNTERS_PG_NAME_MAP', 'COUNTERS_QUEUE_NAME_MAP'
]
tf_rest_data.max_time_to_check_sys_maps = [150, 2] # Seconds
tf_rest_data.default_threshold_value = 0 # Percentage
# Common Constants
tf_rest_data.pg_headroom_un_supported_platforms = \
hw_constants['THRESHOLD_FEATURE_PG_HEADROOM_UN_SUPPORTED_PLATFORMS']
tf_rest_data.build_product_info = hw_constants[
'BUILD_BROADCOM_CLOUD_ADVANCED'] + hw_constants[
'BUILD_BROADCOM_ENTERPRISE_ADVANCED']
def vlan_module_hooks(request):
global vars
vars = st.ensure_min_topology("D1D2:2", "D1T1:2", "D2T1:2")
sc_data.version_data = basic_obj.show_version(vars.D1)
vlan_variables()
if not st.is_feature_supported("vlan-range", vars.D1):
sc_data.max_vlan = 100
[_, exceptions] = exec_all(True, [[config_tg_stream], [vlan_module_prolog]], first_on_main=True)
ensure_no_exception(exceptions)
yield
vlan.clear_vlan_configuration(st.get_dut_names(), thread=False)
def storm_control_module_hooks(request):
global vars
vars = st.ensure_min_topology("D1D2:2", "D1T1:2", "D2T1:2")
sc_data.version_data = basic_obj.show_version(vars.D1)
vlan_variables()
[out, exceptions] = exec_all(True,
[[config_tg_stream], [vlan_module_prolog]],
first_on_main=True)
ensure_no_exception(exceptions)
yield
vlan.clear_vlan_configuration(st.get_dut_names(),
thread=False,
cli_type="click")
def get_params():
pddf_data.base_mac_address = baapi.get_ifconfig_ether(vars.D1, "eth0")
pddf_data.platform_name_summary = baapi.get_platform_summary(vars.D1)
pddf_data.platform_hwsku = pddf_data.platform_name_summary["hwsku"].lower()
platform_check()
pddf_data.platform_name = pddf_data.platform_name_summary["platform"]
pddf_data.serial_number = baapi.show_version(vars.D1)['serial_number']
pddf_data.platform_constants = st.get_datastore(vars.D1, "constants",
pddf_data.platform_hwsku)
pddf_data.fan_list = pddf_data.platform_constants.get(
"PDDF_FANS_LIST", None)
pddf_data.psu_list = pddf_data.platform_constants.get(
"PDDF_PSU_LIST", None)
pddf_data.thermal_list = pddf_data.platform_constants.get(
"PDDF_THERMAL_LIST", None)
pddf_data.manufacturer = pddf_data.platform_constants.get(
"Manufacturer", None)
if not all([
pddf_data.fan_list, pddf_data.psu_list, pddf_data.thermal_list,
pddf_data.manufacturer
]):
st.report_env_fail("pddf_get_constanc_fail", pddf_data.feature,
pddf_data.platform_hwsku)
pddf_data.up_port_list = intapi.get_up_interfaces(vars.D1)
if not pddf_data.up_port_list:
st.report_env_fail("up_interface_not_found", pddf_data.feature)
pddf_data.up_port = get_sfpytils_supported_up_interface()
if any("/" in interface
for interface in make_list(pddf_data.up_port_list)):
pddf_data.up_port_list = st.get_other_names(
vars.D1, make_list(pddf_data.up_port_list))
pddf_data.alias_up_port = st.get_other_names(
vars.D1, make_list(pddf_data.up_port))[0]
else:
pddf_data.alias_up_port = pddf_data.up_port
#Removed Warm reboot as it's not supported in Buzznik+
pddf_data.reboot_cause_dict = {
'warm': 'warm-reboot',
'fast': 'fast-reboot',
'normal': "issued 'reboot'"
}
pddf_data.reboot_type = random.sample(pddf_data.reboot_cause_dict.keys(),
k=1)[0]
if pddf_data.platform_hwsku not in pddf_data.hw_constants[
'WARM_REBOOT_SUPPORTED_PLATFORMS']:
pddf_data.reboot_cause_dict.pop('warm')
pddf_data.reboot_type = random.sample(
pddf_data.reboot_cause_dict.keys(), k=1)[0]
def test_ft_snmp_sysDescr():
"""
Author : Karthikeya Kumar CH<*****@*****.**>
Verify that the sysDescr MIB object functions properly.
Reference Test Bed : D1 --- Mgmt Network
"""
descrip_output = basic_obj.show_version(vars.D1)["hwsku"]
get_snmp_output = snmp_obj.get_snmp_operation(
ipaddress=ipaddress,
oid=data.oid_sysDescr,
community_name=data.ro_community)
get_snmp_output = get_snmp_output[0]
get_snmp_output_value = get_snmp_output.split(' - ')[1].split(
':')[1].strip()
if not descrip_output == get_snmp_output_value:
st.report_fail("sysDescr_verification_fail")
st.report_pass("test_case_passed")
def get_vars(dut):
from spytest import st
from apis.system.basic import show_version
retval = dict()
retval["constants"] = st.get_datastore(dut, "constants")
retval["vervars"] = st.get_datastore(dut, "vervars")
version_data = show_version(dut)
if not version_data and st.is_dry_run(): return retval
retval["product"] = version_data['product']
retval["hwsku"] = version_data['hwsku']
retval["version"] = version_data['version']
for version in ["3.0.x.0", "3.0.1"]:
if version in retval["version"]:
retval["vervars"] = st.get_datastore(dut, "vervars", version)
if retval["vervars"]:
for name, val in retval["vervars"].items():
st.log("VERVARS ({}) - {} = {}".format(dut, name, val))
return retval
def test_ft_pmon_docker_restart():
"""
Author : Karthikeya Kumar CH<*****@*****.**>
Verify that the platform monitoring(pmon) works fine after docker restart
Reference Test Bed : D1 --- Mgmt Network
"""
vars = st.get_testbed_vars()
service_name = "pmon"
basic_obj.service_operations_by_systemctl(vars.D1, service_name, 'stop')
basic_obj.service_operations_by_systemctl(vars.D1, service_name, 'restart')
if not basic_obj.poll_for_system_status(vars.D1, service_name, 30, 1):
st.report_fail("service_not_running", service_name)
if not basic_obj.verify_service_status(vars.D1, service_name):
st.report_fail("pmon_service_not_up")
pmon_check = basic_obj.show_version(vars.D1)
if not pmon_check:
st.report_fail("pmon_show_command_fail")
st.report_pass("test_case_passed")
def show_version(self, dut):
cli_type = st.getenv("SPYTEST_HOOKS_VERSION_UITYPE", "click")
return basic.show_version(dut, cli_type=cli_type)
def validate_image(dut):
tc_list = [
'verify_system_status', 'verify_show_version', 'show_platform_summary',
'show_platform_syseprom', 'show_interface_status'
]
result_count = len(tc_list)
st.log('Executing Image Validation Tests on: {}'.format(
data.dut_platform_info[dut]))
version_op = basic_api.show_version(dut)
if data.dut_version_info[dut] in version_op['version']:
st.log('Build: {}, DUT: {}, Platform: {}, TestCase: {} Passed'.format(
version_op['version'], dut, data.dut_platform_info[dut],
tc_list[1]))
result_count -= 1
else:
st.log('Build: {}, DUT: {}, Platform: {}, TestCase: {} Failed'.format(
version_op['version'], dut, data.dut_platform_info[dut],
tc_list[1]))
if basic_api.get_system_status(dut):
st.log('Build: {}, DUT: {}, Platform: {}, TestCase: {} Passed'.format(
version_op['version'], dut, data.dut_platform_info[dut],
tc_list[0]))
result_count -= 1
else:
st.log('Build: {}, DUT: {}, Platform: {}, TestCase: {} Failed'.format(
version_op['version'], dut, data.dut_platform_info[dut],
tc_list[0]))
plat_sum_op = basic_api.get_platform_summary(dut)
if data.dut_platform_info[dut].lower() in plat_sum_op['platform'].lower():
st.log('Build: {}, DUT: {}, Platform: {}, TestCase: {} Passed'.format(
version_op['version'], dut, data.dut_platform_info[dut],
tc_list[2]))
result_count -= 1
else:
st.log('Build: {}, DUT: {}, Platform: {}, TestCase: {} Failed'.format(
version_op['version'], dut, data.dut_platform_info[dut],
tc_list[2]))
st.log(plat_sum_op)
plat_eep_op = basic_api.get_platform_syseeprom(dut)
if plat_eep_op:
st.log('Build: {}, DUT: {}, Platform: {}, TestCase: {} Passed'.format(
version_op['version'], dut, data.dut_platform_info[dut],
tc_list[3]))
result_count -= 1
else:
st.log('Build: {}, DUT: {}, Platform: {}, TestCase: {} Failed'.format(
version_op['version'], dut, data.dut_platform_info[dut],
tc_list[3]))
st.log(plat_eep_op)
intf_status_op = intf_api.interface_status_show(dut)
if intf_status_op:
st.log('Build: {}, DUT: {}, Platform: {}, TestCase: {} Passed'.format(
version_op['version'], dut, data.dut_platform_info[dut],
tc_list[4]))
result_count -= 1
else:
st.log('Build: {}, DUT: {}, Platform: {}, TestCase: {} Failed'.format(
version_op['version'], dut, data.dut_platform_info[dut],
tc_list[4]))
if result_count == 0:
st.log('Image Validation on platform {}: Passed'.format(
data.dut_platform_info[dut]))
st.report_pass('test_case_passed')
else:
st.log('Image Validation on platform {}: Failed'.format(
data.dut_platform_info[dut]))
st.report_fail('test_case_failed')
def initialize_variables():
global data
global tg
global tg_handler
data = SpyTestDict()
data.session_name = "Mirror_Ses"
data.gre_type = "0x88ee"
data.dscp = "50"
data.ttl = "100"
data.queue = "0"
data.type = 'mirror'
data.source_ip = '11.1.1.2'
data.destination_ip = '15.1.1.2'
data.mode_high = 'high'
data.mode_low = 'low'
data.polling_interval = '1'
data.threshold_percentage_type = 'percentage'
data.threshold_used_type = 'used'
data.threshold_free_type = 'free'
data.ipv4_route_family = "ipv4_route"
data.ipv6_route_family = "ipv6_route"
data.fdb_family = "fdb"
data.ipv4_neighbor_family = "ipv4_neighbor"
data.ipv6_neighbor_family = "ipv6_neighbor"
data.acl_group_entry_family = 'acl_group_entry'
data.acl_group_counter_family = 'acl_group_counter'
data.ipv6_nexthop_family = 'ipv6_nexthop'
data.ipv4_nexthop_family = 'ipv4_nexthop'
data.acl_table_family = "acl_table"
data.mode_high_percentage = 50
data.mode_low_percentage = 20
data.mode_high_used = 1000
data.mode_low_used = 10
data.mode_high_free = 1000
data.mode_low_free = 10
data.mtu = "9216"
data.eth = st.get_free_ports(vars.D1)[0]
data.property = "mtu"
data.mtu_default = "9100"
data.vlan = str(random_vlan_list()[0])
data.kbps = 1000
data.frame_size = 68
data.rate_pps = 5000
data.packets = (data.kbps * 1024) / (data.frame_size * 8)
data.bum_deviation = int(0.10 * data.packets)
data.lower_pkt_count = int(data.packets - data.bum_deviation)
data.higher_pkt_count = int(data.packets + data.bum_deviation)
data.wait_stream_run = 10
data.wait_for_stats = 10
data.session_name_port = "Mirror1"
data.mirror_type = "span"
data.mirror_interface = vars.D1T1P2
data.source_interface = vars.D1T1P1
data.direction_list = "rx"
data.collector_name_1 = "collector_1"
data.collector_name_2 = "collector_2"
data.shell_sonic = "sonic"
data.ip4_addr = ["192.168.4.4"]
data.ip6_addr = ["2001::1"]
data.non_default_udp_port = "4451"
data.default_udp_port = "6343"
tg_handler = tgapi.get_handles_byname("T1D1P1", "T1D1P2")
tg = tg_handler["tg"]
tg_info['tg_info'] = tg_handler
data.hw_constants_DUT = st.get_datastore(vars.D1, "constants")
data.version_data = basic_obj.show_version(vars.D1)
