diff --git a/tests/common/plugins/conditional_mark/tests_mark_conditions.yaml b/tests/common/plugins/conditional_mark/tests_mark_conditions.yaml index cce65fba885..b1e3517e7fd 100644 --- a/tests/common/plugins/conditional_mark/tests_mark_conditions.yaml +++ b/tests/common/plugins/conditional_mark/tests_mark_conditions.yaml @@ -1834,13 +1834,13 @@ snappi_tests/ecn/test_red_accuracy_with_snappi: - "topo_type in ['tgen']" - "asic_type in ['vs']" - - -snappi_tests/multidut/pfc/test_multidut_global_pause_with_snappi.py: +snappi_tests/pfc/test_global_pause_with_snappi.py: skip: - reason: "Global pause is not supported in cisco-8000." + reason: "Global pause is not supported in cisco-8000. / Snappi test only support on physical tgen testbed" + conditions_logical_operator: and conditions: - - "asic_type in ['cisco-8000']" + - "asic_type in ['cisco-8000', 'vs']" + - "topo_type in ['t2', 'multidut-tgen']" ####################################### ##### snmp ##### diff --git a/tests/snappi_tests/multidut/pfc/__init__.py b/tests/snappi_tests/multidut/pfc/__init__.py deleted file mode 100644 index e69de29bb2d..00000000000 diff --git a/tests/snappi_tests/multidut/pfc/files/__init__.py b/tests/snappi_tests/multidut/pfc/files/__init__.py deleted file mode 100644 index e69de29bb2d..00000000000 diff --git a/tests/snappi_tests/multidut/pfc/files/multidut_helper.py b/tests/snappi_tests/multidut/pfc/files/multidut_helper.py deleted file mode 100644 index 268301c626d..00000000000 --- a/tests/snappi_tests/multidut/pfc/files/multidut_helper.py +++ /dev/null @@ -1,419 +0,0 @@ -import logging -import time - -from tests.common.helpers.assertions import pytest_assert -from tests.common.fixtures.conn_graph_facts import conn_graph_facts,\ - fanout_graph_facts # noqa F401 -from tests.common.snappi_tests.common_helpers import pfc_class_enable_vector,\ - get_lossless_buffer_size, get_pg_dropped_packets,\ - disable_packet_aging, enable_packet_aging, sec_to_nanosec,\ - get_pfc_frame_count, packet_capture, config_capture_pkt,\ - traffic_flow_mode, calc_pfc_pause_flow_rate, get_tx_frame_count # noqa F401 -from tests.common.snappi_tests.port import select_ports, select_tx_port # noqa F401 -from tests.common.snappi_tests.snappi_helpers import wait_for_arp # noqa F401 -from tests.common.snappi_tests.traffic_generation import setup_base_traffic_config, generate_test_flows, \ - generate_background_flows, generate_pause_flows, run_traffic, verify_pause_flow, verify_basic_test_flow, \ - verify_background_flow, verify_pause_frame_count_dut, verify_egress_queue_frame_count, \ - verify_in_flight_buffer_pkts, verify_unset_cev_pause_frame_count, verify_tx_frame_count_dut, \ - verify_rx_frame_count_dut -from tests.common.snappi_tests.snappi_test_params import SnappiTestParams -from tests.common.snappi_tests.read_pcap import validate_pfc_frame - - -logger = logging.getLogger(__name__) - -dut_port_config = [] -PAUSE_FLOW_NAME = 'Pause Storm' -TEST_FLOW_NAME = 'Test Flow' -TEST_FLOW_AGGR_RATE_PERCENT = 45 -BG_FLOW_NAME = 'Background Flow' -BG_FLOW_AGGR_RATE_PERCENT = 45 -data_flow_pkt_size = 1024 -DATA_FLOW_DURATION_SEC = 15 -data_flow_delay_sec = 1 -SNAPPI_POLL_DELAY_SEC = 2 -PAUSE_FLOW_DUR_BASE_SEC = data_flow_delay_sec + DATA_FLOW_DURATION_SEC -TOLERANCE_THRESHOLD = 0.05 -CONTINUOUS_MODE = -5 -ANSIBLE_POLL_DELAY_SEC = 4 - - -def run_pfc_test(api, - testbed_config, - port_config_list, - conn_data, - fanout_data, - global_pause, - pause_prio_list, - test_prio_list, - bg_prio_list, - prio_dscp_map, - test_traffic_pause, - test_flow_is_lossless=True, - snappi_extra_params=None, - flow_factor=1): - """ - Run a multidut PFC test - Args: - api (obj): snappi session - testbed_config (obj): testbed L1/L2/L3 configuration - port_config_list (list): list of port configuration - conn_data (dict): the dictionary returned by conn_graph_fact. - fanout_data (dict): the dictionary returned by fanout_graph_fact. - duthost (Ansible host instance): device under test - dut_port (str): DUT port to test - global_pause (bool): if pause frame is IEEE 802.3X pause - pause_prio_list (list): priorities to pause for pause frames - test_prio_list (list): priorities of test flows - bg_prio_list (list): priorities of background flows - prio_dscp_map (dict): Priority vs. DSCP map (key = priority). - test_traffic_pause (bool): if test flows are expected to be paused - snappi_extra_params (SnappiTestParams obj): additional parameters for Snappi traffic - - Returns: - N/A - """ - - if snappi_extra_params is None: - snappi_extra_params = SnappiTestParams() - - # Traffic flow: - # tx_port (TGEN) --- ingress DUT --- egress DUT --- rx_port (TGEN) - - # initialize the (duthost, port) set. - dut_asics_to_be_configured = set() - - rx_port = snappi_extra_params.multi_dut_params.multi_dut_ports[0] - egress_duthost = rx_port['duthost'] - dut_asics_to_be_configured.add((egress_duthost, rx_port['asic_value'])) - - tx_port = snappi_extra_params.multi_dut_params.multi_dut_ports[1] - ingress_duthost = tx_port['duthost'] - dut_asics_to_be_configured.add((ingress_duthost, tx_port['asic_value'])) - - pytest_assert(testbed_config is not None, 'Fail to get L2/3 testbed config') - - global DATA_FLOW_DURATION_SEC - global data_flow_delay_sec - - # Port id of Rx port for traffic config - port_id = 0 - - # Rate percent must be an integer - bg_flow_rate_percent = int((BG_FLOW_AGGR_RATE_PERCENT / flow_factor) / len(bg_prio_list)) - test_flow_rate_percent = int((TEST_FLOW_AGGR_RATE_PERCENT / flow_factor) / len(test_prio_list)) - - # Generate base traffic config - snappi_extra_params.base_flow_config = setup_base_traffic_config(testbed_config=testbed_config, - port_config_list=port_config_list, - port_id=port_id) - - speed_str = testbed_config.layer1[0].speed - speed_gbps = int(float(speed_str.split('_')[1])) - - if snappi_extra_params.headroom_test_params is not None: - DATA_FLOW_DURATION_SEC += 10 - data_flow_delay_sec += 2 - - # Set up pfc delay parameter - l1_config = testbed_config.layer1[0] - pfc = l1_config.flow_control.ieee_802_1qbb - pfc.pfc_delay = snappi_extra_params.headroom_test_params[0] - - if snappi_extra_params.poll_device_runtime: - # If the switch needs to be polled as traffic is running for stats, - # then the test runtime needs to be increased for the polling delay - DATA_FLOW_DURATION_SEC += ANSIBLE_POLL_DELAY_SEC - data_flow_delay_sec = ANSIBLE_POLL_DELAY_SEC - - if snappi_extra_params.packet_capture_type != packet_capture.NO_CAPTURE: - # Setup capture config - if snappi_extra_params.is_snappi_ingress_port_cap: - # packet capture is required on the ingress snappi port - snappi_extra_params.packet_capture_ports = [snappi_extra_params.base_flow_config["rx_port_name"]] - else: - # packet capture will be on the egress snappi port - snappi_extra_params.packet_capture_ports = [snappi_extra_params.base_flow_config["tx_port_name"]] - - snappi_extra_params.packet_capture_file = snappi_extra_params.packet_capture_type.value - - config_capture_pkt(testbed_config=testbed_config, - port_names=snappi_extra_params.packet_capture_ports, - capture_type=snappi_extra_params.packet_capture_type, - capture_name=snappi_extra_params.packet_capture_file) - logger.info("Packet capture file: {}.pcapng".format(snappi_extra_params.packet_capture_file)) - - # Set default traffic flow configs if not set - if snappi_extra_params.traffic_flow_config.data_flow_config is None: - snappi_extra_params.traffic_flow_config.data_flow_config = { - "flow_name": TEST_FLOW_NAME, - "flow_dur_sec": DATA_FLOW_DURATION_SEC, - "flow_rate_percent": test_flow_rate_percent, - "flow_rate_pps": None, - "flow_rate_bps": None, - "flow_pkt_size": data_flow_pkt_size, - "flow_pkt_count": None, - "flow_delay_sec": data_flow_delay_sec, - "flow_traffic_type": traffic_flow_mode.FIXED_DURATION - } - - if snappi_extra_params.traffic_flow_config.background_flow_config is None and \ - snappi_extra_params.gen_background_traffic: - snappi_extra_params.traffic_flow_config.background_flow_config = { - "flow_name": BG_FLOW_NAME, - "flow_dur_sec": DATA_FLOW_DURATION_SEC, - "flow_rate_percent": bg_flow_rate_percent, - "flow_rate_pps": None, - "flow_rate_bps": None, - "flow_pkt_size": data_flow_pkt_size, - "flow_pkt_count": None, - "flow_delay_sec": data_flow_delay_sec, - "flow_traffic_type": traffic_flow_mode.FIXED_DURATION - } - - if snappi_extra_params.traffic_flow_config.pause_flow_config is None: - snappi_extra_params.traffic_flow_config.pause_flow_config = { - "flow_name": PAUSE_FLOW_NAME, - "flow_dur_sec": None, - "flow_rate_percent": None, - "flow_rate_pps": calc_pfc_pause_flow_rate(speed_gbps), - "flow_rate_bps": None, - "flow_pkt_size": 64, - "flow_pkt_count": None, - "flow_delay_sec": 0, - "flow_traffic_type": traffic_flow_mode.CONTINUOUS - } - - if snappi_extra_params.packet_capture_type == packet_capture.PFC_CAPTURE: - # PFC pause frame capture is requested - valid_pfc_frame_test = True - else: - # PFC pause frame capture is not requested - valid_pfc_frame_test = False - - if valid_pfc_frame_test: - snappi_extra_params.traffic_flow_config.pause_flow_config["flow_dur_sec"] = DATA_FLOW_DURATION_SEC + \ - data_flow_delay_sec + SNAPPI_POLL_DELAY_SEC + PAUSE_FLOW_DUR_BASE_SEC - snappi_extra_params.traffic_flow_config.pause_flow_config["flow_traffic_type"] = \ - traffic_flow_mode.FIXED_DURATION - - no_of_streams = 1 - if egress_duthost.facts['asic_type'] == "cisco-8000": - if not test_flow_is_lossless: - no_of_streams = 6 - - # Generate test flow config - generate_test_flows(testbed_config=testbed_config, - test_flow_prio_list=test_prio_list, - prio_dscp_map=prio_dscp_map, - number_of_streams=no_of_streams, - snappi_extra_params=snappi_extra_params) - - if snappi_extra_params.gen_background_traffic: - # Generate background flow config - generate_background_flows(testbed_config=testbed_config, - bg_flow_prio_list=bg_prio_list, - prio_dscp_map=prio_dscp_map, - snappi_extra_params=snappi_extra_params) - - # Generate pause storm config - generate_pause_flows(testbed_config=testbed_config, - pause_prio_list=pause_prio_list, - global_pause=global_pause, - snappi_extra_params=snappi_extra_params) - - flows = testbed_config.flows - - all_flow_names = [flow.name for flow in flows] - data_flow_names = [flow.name for flow in flows if PAUSE_FLOW_NAME not in flow.name] - - # Clear PFC, queue and interface counters before traffic run - duthost = egress_duthost - duthost.command("pfcstat -c") - time.sleep(1) - duthost.command("sonic-clear queuecounters") - time.sleep(1) - duthost.command("sonic-clear counters") - time.sleep(1) - - """ Run traffic """ - tgen_flow_stats, switch_flow_stats, in_flight_flow_metrics = run_traffic(duthost=duthost, - api=api, - config=testbed_config, - data_flow_names=data_flow_names, - all_flow_names=all_flow_names, - exp_dur_sec=DATA_FLOW_DURATION_SEC + - data_flow_delay_sec, - snappi_extra_params=snappi_extra_params) - - # Reset pfc delay parameter - pfc = testbed_config.layer1[0].flow_control.ieee_802_1qbb - pfc.pfc_delay = 0 - - # Verify PFC pause frames - if valid_pfc_frame_test: - is_valid_pfc_frame, error_msg = validate_pfc_frame(snappi_extra_params.packet_capture_file + ".pcapng") - pytest_assert(is_valid_pfc_frame, error_msg) - return - - # Verify pause flows - verify_pause_flow(flow_metrics=tgen_flow_stats, - pause_flow_name=PAUSE_FLOW_NAME) - - if snappi_extra_params.gen_background_traffic: - # Verify background flows - verify_background_flow(flow_metrics=tgen_flow_stats, - speed_gbps=speed_gbps, - tolerance=TOLERANCE_THRESHOLD, - snappi_extra_params=snappi_extra_params) - - # Verify basic test flows metrics from ixia - verify_basic_test_flow(flow_metrics=tgen_flow_stats, - speed_gbps=speed_gbps, - tolerance=TOLERANCE_THRESHOLD, - test_flow_pause=test_traffic_pause, - snappi_extra_params=snappi_extra_params) - - # Verify PFC pause frame count on the DUT - verify_pause_frame_count_dut(rx_dut=ingress_duthost, - tx_dut=egress_duthost, - test_traffic_pause=test_traffic_pause, - global_pause=global_pause, - snappi_extra_params=snappi_extra_params) - - # Verify in flight TX lossless packets do not leave the DUT when traffic is expected - # to be paused, or leave the DUT when the traffic is not expected to be paused - # Verifying the packets on DUT egress, especially for multi line card scenario - verify_egress_queue_frame_count(duthost=egress_duthost, - switch_flow_stats=switch_flow_stats, - test_traffic_pause=test_traffic_pause, - snappi_extra_params=snappi_extra_params) - - if test_traffic_pause: - # Verify in flight TX packets count relative to switch buffer size - verify_in_flight_buffer_pkts(egress_duthost=egress_duthost, - ingress_duthost=ingress_duthost, - flow_metrics=in_flight_flow_metrics, - snappi_extra_params=snappi_extra_params, - asic_value=tx_port['asic_value']) - else: - # Verify zero pause frames are counted when the PFC class enable vector is not set - verify_unset_cev_pause_frame_count(duthost=duthost, - snappi_extra_params=snappi_extra_params) - - if test_traffic_pause and not snappi_extra_params.gen_background_traffic: - # Verify TX frame count on the DUT when traffic is expected to be paused - # and only test traffic flows are generated - verify_tx_frame_count_dut(duthost=duthost, - snappi_extra_params=snappi_extra_params) - - # Verify TX frame count on the DUT when traffic is expected to be paused - # and only test traffic flows are generated - verify_rx_frame_count_dut(duthost=duthost, - snappi_extra_params=snappi_extra_params) - - -def run_tx_drop_counter( - api, - testbed_config, - port_config_list, - dut_port, - test_prio_list, - prio_dscp_map, - snappi_extra_params=None): - - pytest_assert(testbed_config is not None, 'Failed to get L2/3 testbed config') - - if snappi_extra_params is None: - snappi_extra_params = SnappiTestParams() - - rx_port = snappi_extra_params.multi_dut_params.multi_dut_ports[0] - duthost = rx_port['duthost'] - port_id = 0 - - # Generate base traffic config - snappi_extra_params.base_flow_config = setup_base_traffic_config(testbed_config=testbed_config, - port_config_list=port_config_list, - port_id=port_id) - - test_flow_rate_percent = int(TEST_FLOW_AGGR_RATE_PERCENT / len(test_prio_list)) - - # Set default traffic flow configs if not set - if snappi_extra_params.traffic_flow_config.data_flow_config is None: - snappi_extra_params.traffic_flow_config.data_flow_config = { - "flow_name": TEST_FLOW_NAME, - "flow_dur_sec": DATA_FLOW_DURATION_SEC, - "flow_rate_percent": test_flow_rate_percent, - "flow_rate_pps": None, - "flow_rate_bps": None, - "flow_pkt_size": data_flow_pkt_size, - "flow_pkt_count": None, - "flow_delay_sec": data_flow_delay_sec, - "flow_traffic_type": traffic_flow_mode.FIXED_DURATION - } - - # Generate test flow config - generate_test_flows(testbed_config=testbed_config, - test_flow_prio_list=test_prio_list, - prio_dscp_map=prio_dscp_map, - snappi_extra_params=snappi_extra_params) - - flows = testbed_config.flows - - all_flow_names = [flow.name for flow in flows] - data_flow_names = [flow.name for flow in flows if PAUSE_FLOW_NAME not in flow.name] - - duthost.command("sonic-clear counters") - duthost.command("sonic-clear queuecounters") - # Collect metrics from DUT before traffic - tx_ok_frame_count, tx_dut_drop_frames = get_tx_frame_count(duthost, dut_port) - - """ Run traffic """ - tgen_flow_stats, _, _ = run_traffic( - duthost=duthost, - api=api, - config=testbed_config, - data_flow_names=data_flow_names, - all_flow_names=all_flow_names, - exp_dur_sec=DATA_FLOW_DURATION_SEC + - data_flow_delay_sec, - snappi_extra_params=snappi_extra_params) - link_state = None - try: - time.sleep(1) - # Collect metrics from DUT once again - tx_ok_frame_count_1, tx_dut_drop_frames_1 = get_tx_frame_count(duthost, dut_port) - - pytest_assert(tx_ok_frame_count_1 > tx_ok_frame_count and tx_dut_drop_frames_1 == tx_dut_drop_frames, - "DUT Port {} : TX ok counter before {} after {}, Tx drop counter before {} after {} not expected". - format(dut_port, tx_ok_frame_count, tx_ok_frame_count_1, - tx_dut_drop_frames, tx_dut_drop_frames_1)) - - # Set port name of the Ixia port connected to dut_port - port_names = snappi_extra_params.base_flow_config["rx_port_name"] - # Create a link state object for ports - link_state = api.link_state() - # Apply the state to port - link_state.port_names = [port_names] - # Set port down (shut) - link_state.state = link_state.DOWN - api.set_link_state(link_state) - logger.info("Snappi port {} is set to DOWN".format(port_names)) - time.sleep(1) - # Collect metrics from DUT again - _, tx_dut_drop_frames = get_tx_frame_count(duthost, dut_port) - - logger.info("Sleeping for 90 seconds") - time.sleep(90) - # Collect metrics from DUT once again - _, tx_dut_drop_frames_1 = get_tx_frame_count(duthost, dut_port) - - pytest_assert(tx_dut_drop_frames == tx_dut_drop_frames_1, - "Mismatch in TX drop counters post DUT port {} oper down".format(dut_port)) - finally: - if link_state: - # Bring the link back up - link_state.state = link_state.UP - api.set_link_state(link_state) - logger.info("Snappi port {} is set to UP".format(port_names)) - return diff --git a/tests/snappi_tests/multidut/pfc/test_multidut_global_pause_with_snappi.py b/tests/snappi_tests/multidut/pfc/test_multidut_global_pause_with_snappi.py deleted file mode 100644 index 713b3a13b09..00000000000 --- a/tests/snappi_tests/multidut/pfc/test_multidut_global_pause_with_snappi.py +++ /dev/null @@ -1,96 +0,0 @@ -import pytest -import logging -from tests.common.helpers.assertions import pytest_require, pytest_assert # noqa: F401 -from tests.common.fixtures.conn_graph_facts import conn_graph_facts, fanout_graph_facts, \ - fanout_graph_facts_multidut # noqa: F401 -from tests.common.snappi_tests.snappi_fixtures import snappi_api_serv_ip, snappi_api_serv_port, \ - snappi_api, get_snappi_ports, is_snappi_multidut, \ - get_snappi_ports_single_dut, snappi_testbed_config, \ - get_snappi_ports_multi_dut, snappi_dut_base_config, cleanup_config, get_snappi_ports_for_rdma # noqa: F401 -from tests.common.snappi_tests.qos_fixtures import lossless_prio_list, prio_dscp_map, disable_pfcwd # noqa: F401 -from tests.snappi_tests.multidut.pfc.files.multidut_helper import run_pfc_test # noqa: F401 -from tests.common.snappi_tests.snappi_test_params import SnappiTestParams -from tests.snappi_tests.variables import MULTIDUT_PORT_INFO, MULTIDUT_TESTBED - -logger = logging.getLogger(__name__) - -pytestmark = [pytest.mark.topology('multidut-tgen', 'tgen')] - - -@pytest.mark.parametrize("multidut_port_info", MULTIDUT_PORT_INFO[MULTIDUT_TESTBED]) -def test_global_pause(snappi_api, # noqa: F811 - conn_graph_facts, # noqa: F811 - fanout_graph_facts_multidut, # noqa: F811 - get_snappi_ports, # noqa: F811 - duthosts, - prio_dscp_map, # noqa: F811 - lossless_prio_list, # noqa: F811 - tbinfo, # noqa: F811 - multidut_port_info, - disable_pfcwd): # noqa: F811 - """ - Test if IEEE 802.3X pause (a.k.a., global pause) will impact any priority - - Args: - snappi_api (pytest fixture): SNAPPI session - conn_graph_facts (pytest fixture): connection graph - fanout_graph_facts_multidut (pytest fixture): fanout graph for multiple duts - get_snappi_ports (pytest fixture): list of snappi port and duthost information - duthosts (pytest fixture): list of DUTs - lossless_prio_list (pytest fixture): list of all the lossless priorities - prio_dscp_map (pytest fixture): priority vs. DSCP map (key = priority). - tbinfo (pytest fixture): fixture provides information about testbed - get_snappi_ports (pytest fixture): gets snappi ports and connected DUT port info and returns as a list - Returns: - N/A - """ - snappi_port_list = get_snappi_ports - - tbname = tbinfo.get('conf-name', None) - - tx_port_count = 1 - rx_port_count = 1 - - pytest_assert(len(snappi_port_list) >= tx_port_count + rx_port_count, - "Need Minimum of 2 ports defined in ansible/files/*links.csv file") - - for testbed_subtype, rdma_ports in multidut_port_info.items(): - pytest_assert(len(rdma_ports['tx_ports']) >= tx_port_count, - 'MULTIDUT_PORT_INFO doesn\'t have the required Tx ports defined for \ - testbed {}, subtype {} in variables.py'. - format(MULTIDUT_TESTBED, testbed_subtype)) - - pytest_assert(len(rdma_ports['rx_ports']) >= rx_port_count, - 'MULTIDUT_PORT_INFO doesn\'t have the required Rx ports defined for \ - testbed {}, subtype {} in variables.py'. - format(tbname, testbed_subtype)) - logger.info('Running test for testbed subtype: {}'.format(testbed_subtype)) - if is_snappi_multidut(duthosts): - snappi_ports = get_snappi_ports_for_rdma(snappi_port_list, rdma_ports, - tx_port_count, rx_port_count, MULTIDUT_TESTBED) - else: - snappi_ports = snappi_port_list - testbed_config, port_config_list, snappi_ports = snappi_dut_base_config(duthosts, - snappi_ports, - snappi_api) - - all_prio_list = prio_dscp_map.keys() - test_prio_list = lossless_prio_list - bg_prio_list = [x for x in all_prio_list if x not in test_prio_list] - - snappi_extra_params = SnappiTestParams() - snappi_extra_params.multi_dut_params.multi_dut_ports = snappi_ports - run_pfc_test(api=snappi_api, - testbed_config=testbed_config, - port_config_list=port_config_list, - conn_data=conn_graph_facts, - fanout_data=fanout_graph_facts_multidut, - global_pause=True, - pause_prio_list=None, - test_prio_list=test_prio_list, - bg_prio_list=bg_prio_list, - prio_dscp_map=prio_dscp_map, - test_traffic_pause=False, - snappi_extra_params=snappi_extra_params) - - cleanup_config(duthosts, snappi_ports) diff --git a/tests/snappi_tests/multidut/pfc/test_multidut_pfc_pause_lossless_with_snappi.py b/tests/snappi_tests/multidut/pfc/test_multidut_pfc_pause_lossless_with_snappi.py deleted file mode 100644 index 769ec5d42cf..00000000000 --- a/tests/snappi_tests/multidut/pfc/test_multidut_pfc_pause_lossless_with_snappi.py +++ /dev/null @@ -1,251 +0,0 @@ -import pytest -from tests.common.helpers.assertions import pytest_require, pytest_assert # noqa: F401 -from tests.common.fixtures.conn_graph_facts import conn_graph_facts, fanout_graph_facts, \ - fanout_graph_facts_multidut # noqa: F401 -from tests.common.snappi_tests.snappi_fixtures import snappi_api_serv_ip, snappi_api_serv_port, \ - snappi_api, snappi_dut_base_config, get_snappi_ports_for_rdma, cleanup_config, get_snappi_ports_multi_dut, \ - snappi_testbed_config, get_snappi_ports_single_dut, \ - get_snappi_ports, is_snappi_multidut # noqa: F401 -from tests.snappi_tests.files.helper import multidut_port_info, setup_ports_and_dut, reboot_duts # noqa: F401 -from tests.common.snappi_tests.qos_fixtures import prio_dscp_map, all_prio_list, lossless_prio_list,\ - lossy_prio_list, disable_pfcwd # noqa F401 -from tests.snappi_tests.multidut.pfc.files.multidut_helper import run_pfc_test -import logging -from tests.common.snappi_tests.snappi_test_params import SnappiTestParams - - -logger = logging.getLogger(__name__) - -pytestmark = [pytest.mark.topology('multidut-tgen', 'tgen')] - - -@pytest.fixture(autouse=True) -def number_of_tx_rx_ports(): - yield (1, 1) - - -def test_pfc_pause_single_lossless_prio(snappi_api, # noqa: F811 - conn_graph_facts, # noqa: F811 - fanout_graph_facts_multidut, # noqa: F811 - duthosts, - enum_one_dut_lossless_prio, - prio_dscp_map, # noqa: F811 - lossless_prio_list, # noqa: F811 - all_prio_list, # noqa: F811 - get_snappi_ports, # noqa: F811 - tbinfo, # noqa: F811 - disable_pfcwd, # noqa: F811 - setup_ports_and_dut): # noqa: F811 - - """ - Test if PFC can pause a single lossless priority in multidut setup - - Args: - snappi_api (pytest fixture): SNAPPI session - conn_graph_facts (pytest fixture): connection graph - fanout_graph_facts_multidut (pytest fixture): fanout graph - duthosts (pytest fixture): list of DUTs - enum_dut_lossless_prio (str): lossless priority to test, e.g., 's6100-1|3' - all_prio_list (pytest fixture): list of all the priorities - prio_dscp_map (pytest fixture): priority vs. DSCP map (key = priority). - lossless_prio_list (pytest fixture): list of all the lossless priorities - tbinfo (pytest fixture): fixture provides information about testbed - get_snappi_ports (pytest fixture): gets snappi ports and connected DUT port info and returns as a list - - Returns: - N/A - """ - - testbed_config, port_config_list, snappi_ports = setup_ports_and_dut - - _, lossless_prio = enum_one_dut_lossless_prio.split('|') - lossless_prio = int(lossless_prio) - pause_prio_list = [lossless_prio] - test_prio_list = [lossless_prio] - bg_prio_list = [p for p in all_prio_list] - bg_prio_list.remove(lossless_prio) - - logger.info("Snappi Ports : {}".format(snappi_ports)) - - snappi_extra_params = SnappiTestParams() - snappi_extra_params.multi_dut_params.multi_dut_ports = snappi_ports - - run_pfc_test(api=snappi_api, - testbed_config=testbed_config, - port_config_list=port_config_list, - conn_data=conn_graph_facts, - fanout_data=fanout_graph_facts_multidut, - global_pause=False, - pause_prio_list=pause_prio_list, - test_prio_list=test_prio_list, - bg_prio_list=bg_prio_list, - prio_dscp_map=prio_dscp_map, - test_traffic_pause=True, - snappi_extra_params=snappi_extra_params) - - -def test_pfc_pause_multi_lossless_prio(snappi_api, # noqa: F811 - conn_graph_facts, # noqa: F811 - fanout_graph_facts_multidut, # noqa: F811 - duthosts, - prio_dscp_map, # noqa: F811 - lossy_prio_list, # noqa: F811 - lossless_prio_list, # noqa: F811 - get_snappi_ports, # noqa: F811 - tbinfo, - disable_pfcwd, # noqa: F811 - setup_ports_and_dut): # noqa: F811 - - """ - Test if PFC can pause multiple lossless priorities in multidut setup - - Args: - snappi_api (pytest fixture): SNAPPI session - conn_graph_facts (pytest fixture): connection graph - fanout_graph_facts_multidut (pytest fixture): fanout graph - duthosts (pytest fixture): list of DUTs - prio_dscp_map (pytest fixture): priority vs. DSCP map (key = priority). - lossless_prio_list (pytest fixture): list of all the lossless priorities - lossy_prio_list (pytest fixture): list of all the lossy priorities - tbinfo (pytest fixture): fixture provides information about testbed - get_snappi_ports (pytest fixture): gets snappi ports and connected DUT port info and returns as a list - Returns: - N/A - """ - testbed_config, port_config_list, snappi_ports = setup_ports_and_dut - - pause_prio_list = lossless_prio_list - test_prio_list = lossless_prio_list - bg_prio_list = lossy_prio_list - logger.info("Snappi Ports : {}".format(snappi_ports)) - - snappi_extra_params = SnappiTestParams() - snappi_extra_params.multi_dut_params.multi_dut_ports = snappi_ports - - run_pfc_test(api=snappi_api, - testbed_config=testbed_config, - port_config_list=port_config_list, - conn_data=conn_graph_facts, - fanout_data=fanout_graph_facts_multidut, - global_pause=False, - pause_prio_list=pause_prio_list, - test_prio_list=test_prio_list, - bg_prio_list=bg_prio_list, - prio_dscp_map=prio_dscp_map, - test_traffic_pause=True, - snappi_extra_params=snappi_extra_params) - - -@pytest.mark.disable_loganalyzer -def test_pfc_pause_single_lossless_prio_reboot(snappi_api, # noqa: F811 - conn_graph_facts, # noqa: F811 - fanout_graph_facts_multidut, # noqa: F811 - duthosts, - localhost, - enum_one_dut_lossless_prio_with_completeness_level, # noqa: F811 - prio_dscp_map, # noqa: F811 - lossless_prio_list, # noqa: F811 - all_prio_list, # noqa: F811 - get_snappi_ports, # noqa: F811 - tbinfo, # noqa: F811 - setup_ports_and_dut, # noqa: F811 - disable_pfcwd, # noqa: F811 - reboot_duts): # noqa: F811 - """ - Test if PFC can pause a single lossless priority even after various types of reboot in multidut setup - - Args: - snappi_api (pytest fixture): SNAPPI session - conn_graph_facts (pytest fixture): connection graph - fanout_graph_facts_multidut (pytest fixture): fanout graph - duthosts (pytest fixture): list of DUTs - localhost (pytest fixture): localhost handle - enum_dut_lossless_prio_with_completeness_level (str): lossless priority to test, e.g., 's6100-1|3' - all_prio_list (pytest fixture): list of all the priorities - prio_dscp_map (pytest fixture): priority vs. DSCP map (key = priority). - lossless_prio_list (pytest fixture): list of all the lossless priorities - tbinfo (pytest fixture): fixture provides information about testbed - get_snappi_ports (pytest fixture): gets snappi ports and connected DUT port info and returns as a list - Returns: - N/A - """ - testbed_config, port_config_list, snappi_ports = setup_ports_and_dut - - _, lossless_prio = enum_one_dut_lossless_prio_with_completeness_level.split('|') - lossless_prio = int(lossless_prio) - pause_prio_list = [lossless_prio] - test_prio_list = [lossless_prio] - bg_prio_list = [p for p in all_prio_list] - bg_prio_list.remove(lossless_prio) - logger.info("Snappi Ports : {}".format(snappi_ports)) - - snappi_extra_params = SnappiTestParams() - snappi_extra_params.multi_dut_params.multi_dut_ports = snappi_ports - - run_pfc_test(api=snappi_api, - testbed_config=testbed_config, - port_config_list=port_config_list, - conn_data=conn_graph_facts, - fanout_data=fanout_graph_facts_multidut, - global_pause=False, - pause_prio_list=pause_prio_list, - test_prio_list=test_prio_list, - bg_prio_list=bg_prio_list, - prio_dscp_map=prio_dscp_map, - test_traffic_pause=True, - snappi_extra_params=snappi_extra_params) - - -@pytest.mark.disable_loganalyzer -def test_pfc_pause_multi_lossless_prio_reboot(snappi_api, # noqa: F811 - conn_graph_facts, # noqa: F811 - fanout_graph_facts_multidut, # noqa: F811 - duthosts, - localhost, - prio_dscp_map, # noqa: F811 - lossy_prio_list, # noqa: F811 - lossless_prio_list, # noqa: F811 - get_snappi_ports, # noqa: F811 - tbinfo, # noqa: F811 - setup_ports_and_dut, # noqa: F811 - disable_pfcwd, # noqa: F811 - reboot_duts): # noqa: F811 - """ - Test if PFC can pause multiple lossless priorities even after various types of reboot in multidut setup - - Args: - snappi_api (pytest fixture): SNAPPI session - conn_graph_facts (pytest fixture): connection graph - fanout_graph_facts_multidut (pytest fixture): fanout graph - duthosts (pytest fixture): list of DUTs - localhost (pytest fixture): localhost handle - prio_dscp_map (pytest fixture): priority vs. DSCP map (key = priority). - lossless_prio_list (pytest fixture): list of all the lossless priorities - lossy_prio_list (pytest fixture): list of all the lossy priorities - tbinfo (pytest fixture): fixture provides information about testbed - get_snappi_ports (pytest fixture): gets snappi ports and connected DUT port info and returns as a list - Returns: - N/A - """ - testbed_config, port_config_list, snappi_ports = setup_ports_and_dut - - pause_prio_list = lossless_prio_list - test_prio_list = lossless_prio_list - bg_prio_list = lossy_prio_list - logger.info("Snappi Ports : {}".format(snappi_ports)) - - snappi_extra_params = SnappiTestParams() - snappi_extra_params.multi_dut_params.multi_dut_ports = snappi_ports - - run_pfc_test(api=snappi_api, - testbed_config=testbed_config, - port_config_list=port_config_list, - conn_data=conn_graph_facts, - fanout_data=fanout_graph_facts_multidut, - global_pause=False, - pause_prio_list=pause_prio_list, - test_prio_list=test_prio_list, - bg_prio_list=bg_prio_list, - prio_dscp_map=prio_dscp_map, - test_traffic_pause=True, - snappi_extra_params=snappi_extra_params) diff --git a/tests/snappi_tests/multidut/pfc/test_multidut_pfc_pause_lossy_with_snappi.py b/tests/snappi_tests/multidut/pfc/test_multidut_pfc_pause_lossy_with_snappi.py deleted file mode 100644 index b65c87b5a89..00000000000 --- a/tests/snappi_tests/multidut/pfc/test_multidut_pfc_pause_lossy_with_snappi.py +++ /dev/null @@ -1,273 +0,0 @@ -import pytest -from tests.common.helpers.assertions import pytest_require, pytest_assert # noqa: F401 -from tests.common.fixtures.conn_graph_facts import conn_graph_facts, fanout_graph_facts, \ - fanout_graph_facts_multidut # noqa: F401 -from tests.common.snappi_tests.snappi_fixtures import snappi_api_serv_ip, snappi_api_serv_port, \ - snappi_api, snappi_dut_base_config, get_snappi_ports_for_rdma, cleanup_config, \ - get_snappi_ports_single_dut, snappi_testbed_config, \ - get_snappi_ports_multi_dut, is_snappi_multidut, \ - get_snappi_ports # noqa: F401 -from tests.common.snappi_tests.qos_fixtures import prio_dscp_map, all_prio_list, lossless_prio_list,\ - lossy_prio_list # noqa F401 -from tests.snappi_tests.variables import MULTIDUT_PORT_INFO, MULTIDUT_TESTBED # noqa: F401 -from tests.snappi_tests.multidut.pfc.files.multidut_helper import run_pfc_test -import logging -from tests.common.snappi_tests.snappi_test_params import SnappiTestParams -from tests.snappi_tests.files.helper import reboot_duts, setup_ports_and_dut, multidut_port_info # noqa: F401 -logger = logging.getLogger(__name__) - -pytestmark = [pytest.mark.topology('multidut-tgen', 'tgen')] - - -@pytest.fixture(autouse=True) -def number_of_tx_rx_ports(): - yield (1, 1) - - -def test_pfc_pause_single_lossy_prio(snappi_api, # noqa: F811 - conn_graph_facts, # noqa: F811 - fanout_graph_facts_multidut, # noqa: F811 - duthosts, - enum_one_dut_lossy_prio, - prio_dscp_map, # noqa: F811 - lossy_prio_list, # noqa: F811 - all_prio_list, # noqa: F811 - lossless_prio_list, # noqa: F811 - get_snappi_ports, # noqa: F811 - tbinfo, # noqa: F811 - setup_ports_and_dut # noqa: F811 - ): - """ - Test if PFC will impact a single lossy priority in multidut setup - - Args: - snappi_api (pytest fixture): SNAPPI session - conn_graph_facts (pytest fixture): connection graph - fanout_graph_facts_multidut (pytest fixture): fanout graph - duthosts (pytest fixture): list of DUTs - enum_dut_lossy_prio (str): name of lossy priority to test, e.g., 's6100-1|2' - prio_dscp_map (pytest fixture): priority vs. DSCP map (key = priority). - lossy_prio_list (pytest fixture): list of all the lossy priorities - all_prio_list (pytest fixture): list of all the priorities - lossy_prio_list (pytest fixture): list of all the lossy priorities - - - Returns: - N/A - """ - testbed_config, port_config_list, snappi_ports = setup_ports_and_dut - - _, lossy_prio = enum_one_dut_lossy_prio.split('|') - lossy_prio = int(lossy_prio) - pause_prio_list = [lossy_prio] - test_prio_list = [lossy_prio] - bg_prio_list = [p for p in all_prio_list] - bg_prio_list.remove(lossy_prio) - - snappi_extra_params = SnappiTestParams() - snappi_extra_params.multi_dut_params.multi_dut_ports = snappi_ports - - flow_factor = 1 - - if snappi_ports[0]['asic_type'] == 'cisco-8000' and int(snappi_ports[0]['speed']) > 200000: - flow_factor = int(snappi_ports[0]['speed']) / 200000 - - run_pfc_test(api=snappi_api, - testbed_config=testbed_config, - port_config_list=port_config_list, - conn_data=conn_graph_facts, - fanout_data=fanout_graph_facts_multidut, - global_pause=False, - pause_prio_list=pause_prio_list, - test_prio_list=test_prio_list, - bg_prio_list=bg_prio_list, - prio_dscp_map=prio_dscp_map, - test_traffic_pause=False, - test_flow_is_lossless=False, - snappi_extra_params=snappi_extra_params, - flow_factor=flow_factor) - - -def test_pfc_pause_multi_lossy_prio(snappi_api, # noqa: F811 - conn_graph_facts, # noqa: F811 - fanout_graph_facts_multidut, # noqa: F811 - duthosts, - prio_dscp_map, # noqa: F811 - lossy_prio_list, # noqa: F811 - lossless_prio_list, # noqa: F811 - get_snappi_ports, # noqa: F811 - tbinfo, # noqa: F811 - setup_ports_and_dut): # noqa: F811 - """ - Test if PFC will impact multiple lossy priorities in multidut setup - - Args: - snappi_api (pytest fixture): SNAPPI session - conn_graph_facts (pytest fixture): connection graph - fanout_graph_facts_multidut (pytest fixture): fanout graph - duthosts (pytest fixture): list of DUTs - prio_dscp_map (pytest fixture): priority vs. DSCP map (key = priority). - lossless_prio_list (pytest fixture): list of all the lossless priorities - lossy_prio_list (pytest fixture): list of all the lossy priorities - tbinfo (pytest fixture): fixture provides information about testbed - get_snappi_ports (pytest fixture): gets snappi ports and connected DUT port info and returns as a list - Returns: - N/A - """ - testbed_config, port_config_list, snappi_ports = setup_ports_and_dut - - pause_prio_list = lossy_prio_list - test_prio_list = lossy_prio_list - bg_prio_list = lossless_prio_list - - snappi_extra_params = SnappiTestParams() - snappi_extra_params.multi_dut_params.multi_dut_ports = snappi_ports - - flow_factor = 1 - - if snappi_ports[0]['asic_type'] == 'cisco-8000' and int(snappi_ports[0]['speed']) > 200000: - flow_factor = int(snappi_ports[0]['speed']) / 200000 - - run_pfc_test(api=snappi_api, - testbed_config=testbed_config, - port_config_list=port_config_list, - conn_data=conn_graph_facts, - fanout_data=fanout_graph_facts_multidut, - global_pause=False, - pause_prio_list=pause_prio_list, - test_prio_list=test_prio_list, - bg_prio_list=bg_prio_list, - prio_dscp_map=prio_dscp_map, - test_traffic_pause=False, - test_flow_is_lossless=False, - snappi_extra_params=snappi_extra_params, - flow_factor=flow_factor) - - -@pytest.mark.disable_loganalyzer -def test_pfc_pause_single_lossy_prio_reboot(snappi_api, # noqa: F811 - conn_graph_facts, # noqa: F811 - fanout_graph_facts_multidut, # noqa: F811 - duthosts, - localhost, - enum_one_dut_lossy_prio_with_completeness_level, - prio_dscp_map, # noqa: F811 - lossy_prio_list, # noqa: F811 - all_prio_list, # noqa: F811 - lossless_prio_list, # noqa: F811 - get_snappi_ports, # noqa: F811 - tbinfo, # noqa: F811 - setup_ports_and_dut, # noqa: F811 - reboot_duts): # noqa: F811 - """ - Test if PFC will impact a single lossy priority after various kinds of reboots in multidut setup - - Args: - snappi_api (pytest fixture): SNAPPI session - conn_graph_facts (pytest fixture): connection graph - fanout_graph_facts_multidut (pytest fixture): fanout graph - duthosts (pytest fixture): list of DUTs - localhost (pytest fixture): localhost handle - enum_dut_lossy_prio_with_completeness_level (str): name of lossy priority to test, e.g., 's6100-1|2' - prio_dscp_map (pytest fixture): priority vs. DSCP map (key = priority). - lossy_prio_list (pytest fixture): list of all the lossy priorities - all_prio_list (pytest fixture): list of all the priorities - reboot_type (str): reboot type to be issued on the DUT - tbinfo (pytest fixture): fixture provides information about testbed - get_snappi_ports (pytest fixture): gets snappi ports and connected DUT port info and returns as a list - Returns: - N/A - """ - testbed_config, port_config_list, snappi_ports = setup_ports_and_dut - - _, lossy_prio = enum_one_dut_lossy_prio_with_completeness_level.split('|') - lossy_prio = int(lossy_prio) - pause_prio_list = [lossy_prio] - test_prio_list = [lossy_prio] - bg_prio_list = [p for p in all_prio_list] - bg_prio_list.remove(lossy_prio) - - snappi_extra_params = SnappiTestParams() - snappi_extra_params.multi_dut_params.multi_dut_ports = snappi_ports - - flow_factor = 1 - - if snappi_ports[0]['asic_type'] == 'cisco-8000' and int(snappi_ports[0]['speed']) > 200000: - flow_factor = int(snappi_ports[0]['speed']) / 200000 - - run_pfc_test(api=snappi_api, - testbed_config=testbed_config, - port_config_list=port_config_list, - conn_data=conn_graph_facts, - fanout_data=fanout_graph_facts_multidut, - global_pause=False, - pause_prio_list=pause_prio_list, - test_prio_list=test_prio_list, - bg_prio_list=bg_prio_list, - prio_dscp_map=prio_dscp_map, - test_traffic_pause=False, - test_flow_is_lossless=False, - snappi_extra_params=snappi_extra_params, - flow_factor=flow_factor) - - -@pytest.mark.disable_loganalyzer -def test_pfc_pause_multi_lossy_prio_reboot(snappi_api, # noqa: F811 - conn_graph_facts, # noqa: F811 - fanout_graph_facts_multidut, # noqa: F811 - duthosts, - localhost, - prio_dscp_map, # noqa: F811 - lossy_prio_list, # noqa: F811 - lossless_prio_list, # noqa: F811 - get_snappi_ports, # noqa: F811 - tbinfo, # noqa: F811 - setup_ports_and_dut, # noqa: F811 - reboot_duts): # noqa: F811 - """ - Test if PFC will impact multiple lossy priorities after various kinds of reboots - - Args: - snappi_api (pytest fixture): SNAPPI session - snappi_testbed_config (pytest fixture): testbed configuration information - conn_graph_facts (pytest fixture): connection graph - fanout_graph_facts_multidut (pytest fixture): fanout graph - localhost (pytest fixture): localhost handle - duthosts (pytest fixture): list of DUTs - prio_dscp_map (pytest fixture): priority vs. DSCP map (key = priority). - lossless_prio_list (pytest fixture): list of all the lossless priorities - lossy_prio_list (pytest fixture): list of all the lossy priorities - reboot_type (str): reboot type to be issued on the DUT - tbinfo (pytest fixture): fixture provides information about testbed - get_snappi_ports (pytest fixture): gets snappi ports and connected DUT port info and returns as a list - Returns: - N/A - """ - testbed_config, port_config_list, snappi_ports = setup_ports_and_dut - - pause_prio_list = lossy_prio_list - test_prio_list = lossy_prio_list - bg_prio_list = lossless_prio_list - - snappi_extra_params = SnappiTestParams() - snappi_extra_params.multi_dut_params.multi_dut_ports = snappi_ports - - flow_factor = 1 - - if snappi_ports[0]['asic_type'] == 'cisco-8000' and int(snappi_ports[0]['speed']) > 200000: - flow_factor = int(snappi_ports[0]['speed']) / 200000 - - run_pfc_test(api=snappi_api, - testbed_config=testbed_config, - port_config_list=port_config_list, - conn_data=conn_graph_facts, - fanout_data=fanout_graph_facts_multidut, - global_pause=False, - pause_prio_list=pause_prio_list, - test_prio_list=test_prio_list, - bg_prio_list=bg_prio_list, - prio_dscp_map=prio_dscp_map, - test_traffic_pause=False, - test_flow_is_lossless=False, - snappi_extra_params=snappi_extra_params, - flow_factor=flow_factor) diff --git a/tests/snappi_tests/pfc/files/helper.py b/tests/snappi_tests/pfc/files/helper.py index 564b352076d..5bce0a58787 100644 --- a/tests/snappi_tests/pfc/files/helper.py +++ b/tests/snappi_tests/pfc/files/helper.py @@ -1,24 +1,23 @@ import logging import time +from tests.common.cisco_data import is_cisco_device from tests.common.helpers.assertions import pytest_assert from tests.common.fixtures.conn_graph_facts import conn_graph_facts,\ - fanout_graph_facts # noqa F401 -from tests.common.snappi_tests.snappi_helpers import get_dut_port_id + fanout_graph_facts # noqa F401 from tests.common.snappi_tests.common_helpers import pfc_class_enable_vector,\ get_lossless_buffer_size, get_pg_dropped_packets,\ - stop_pfcwd, disable_packet_aging, sec_to_nanosec,\ + disable_packet_aging, enable_packet_aging, sec_to_nanosec,\ get_pfc_frame_count, packet_capture, config_capture_pkt,\ - traffic_flow_mode, calc_pfc_pause_flow_rate # noqa F401 -from tests.common.snappi_tests.port import select_ports, select_tx_port # noqa F401 -from tests.common.snappi_tests.snappi_helpers import wait_for_arp # noqa F401 + traffic_flow_mode, calc_pfc_pause_flow_rate, get_tx_frame_count # noqa F401 +from tests.common.snappi_tests.port import select_ports, select_tx_port # noqa F401 +from tests.common.snappi_tests.snappi_helpers import get_dut_port_id, wait_for_arp # noqa F401 from tests.common.snappi_tests.traffic_generation import setup_base_traffic_config, generate_test_flows, \ generate_background_flows, generate_pause_flows, run_traffic, verify_pause_flow, verify_basic_test_flow, \ verify_background_flow, verify_pause_frame_count_dut, verify_egress_queue_frame_count, \ verify_in_flight_buffer_pkts, verify_unset_cev_pause_frame_count, verify_tx_frame_count_dut, \ verify_rx_frame_count_dut from tests.common.snappi_tests.snappi_test_params import SnappiTestParams -from tests.common.cisco_data import is_cisco_device from tests.common.snappi_tests.read_pcap import validate_pfc_frame, validate_pfc_frame_cisco @@ -45,17 +44,19 @@ def run_pfc_test(api, port_config_list, conn_data, fanout_data, - duthost, - dut_port, global_pause, pause_prio_list, test_prio_list, bg_prio_list, prio_dscp_map, test_traffic_pause, - snappi_extra_params=None): + duthost=None, + dut_port=None, + test_flow_is_lossless=True, + snappi_extra_params=None, + flow_factor=1): """ - Run a PFC test + Run a multidut PFC test Args: api (obj): snappi session testbed_config (obj): testbed L1/L2/L3 configuration @@ -76,33 +77,44 @@ def run_pfc_test(api, N/A """ - pytest_assert(testbed_config is not None, 'Fail to get L2/3 testbed config') - if snappi_extra_params is None: snappi_extra_params = SnappiTestParams() - stop_pfcwd(duthost) - disable_packet_aging(duthost) + # Traffic flow: + # tx_port (TGEN) --- ingress DUT --- egress DUT --- rx_port (TGEN) + + # initialize the (duthost, port) set. + + rx_port = {} + egress_duthost = duthost + + tx_port = {} + ingress_duthost = duthost + + if not duthost: + rx_port = snappi_extra_params.multi_dut_params.multi_dut_ports[0] + egress_duthost = rx_port['duthost'] + + tx_port = snappi_extra_params.multi_dut_params.multi_dut_ports[1] + ingress_duthost = tx_port['duthost'] + + pytest_assert(testbed_config is not None, 'Fail to get L2/3 testbed config') + global DATA_FLOW_DURATION_SEC global data_flow_delay_sec - # Get the ID of the port to test - port_id = get_dut_port_id(dut_hostname=duthost.hostname, - dut_port=dut_port, - conn_data=conn_data, - fanout_data=fanout_data) + # Port id of Rx port for traffic config + port_id = 0 - pytest_assert(port_id is not None, - 'Fail to get ID for port {}'.format(dut_port)) - - # Single linecard and hence rx_dut and tx_dut are the same. - # rx_dut and tx_dut are used to verify_pause_frame_count - rx_dut = duthost - tx_dut = duthost + if dut_port and duthost: + port_id = get_dut_port_id(dut_hostname=duthost.hostname, + dut_port=dut_port, + conn_data=conn_data, + fanout_data=fanout_data) # Rate percent must be an integer - bg_flow_rate_percent = int(BG_FLOW_AGGR_RATE_PERCENT / len(bg_prio_list)) - test_flow_rate_percent = int(TEST_FLOW_AGGR_RATE_PERCENT / len(test_prio_list)) + bg_flow_rate_percent = int((BG_FLOW_AGGR_RATE_PERCENT / flow_factor) / len(bg_prio_list)) + test_flow_rate_percent = int((TEST_FLOW_AGGR_RATE_PERCENT / flow_factor) / len(test_prio_list)) # Generate base traffic config snappi_extra_params.base_flow_config = setup_base_traffic_config(testbed_config=testbed_config, @@ -110,7 +122,7 @@ def run_pfc_test(api, port_id=port_id) speed_str = testbed_config.layer1[0].speed - speed_gbps = int(speed_str.split('_')[1]) + speed_gbps = int(float(speed_str.split('_')[1])) if snappi_extra_params.headroom_test_params is not None: DATA_FLOW_DURATION_SEC += 10 @@ -192,16 +204,22 @@ def run_pfc_test(api, # PFC pause frame capture is not requested valid_pfc_frame_test = False - if valid_pfc_frame_test and not is_cisco_device(duthost): + if valid_pfc_frame_test and not is_cisco_device(egress_duthost): snappi_extra_params.traffic_flow_config.pause_flow_config["flow_dur_sec"] = DATA_FLOW_DURATION_SEC + \ data_flow_delay_sec + SNAPPI_POLL_DELAY_SEC + PAUSE_FLOW_DUR_BASE_SEC snappi_extra_params.traffic_flow_config.pause_flow_config["flow_traffic_type"] = \ traffic_flow_mode.FIXED_DURATION + no_of_streams = 1 + if egress_duthost.facts['asic_type'] == "cisco-8000": + if not test_flow_is_lossless: + no_of_streams = 6 + # Generate test flow config generate_test_flows(testbed_config=testbed_config, test_flow_prio_list=test_prio_list, prio_dscp_map=prio_dscp_map, + number_of_streams=no_of_streams, snappi_extra_params=snappi_extra_params) if snappi_extra_params.gen_background_traffic: @@ -223,12 +241,15 @@ def run_pfc_test(api, data_flow_names = [flow.name for flow in flows if PAUSE_FLOW_NAME not in flow.name] # Clear PFC, queue and interface counters before traffic run - duthost.command("pfcstat -c") - time.sleep(1) - duthost.command("sonic-clear queuecounters") - time.sleep(1) - duthost.command("sonic-clear counters") - time.sleep(1) + duthost = egress_duthost + + for dut in [egress_duthost, ingress_duthost]: + dut.command("pfcstat -c") + time.sleep(1) + dut.command("sonic-clear queuecounters") + time.sleep(1) + dut.command("sonic-clear counters") + time.sleep(1) """ Run traffic """ tgen_flow_stats, switch_flow_stats, in_flight_flow_metrics = run_traffic(duthost=duthost, @@ -273,27 +294,27 @@ def run_pfc_test(api, snappi_extra_params=snappi_extra_params) # Verify PFC pause frame count on the DUT - # rx_dut is Ingress DUT receiving traffic. - # tx_dut is Egress DUT sending traffic to IXIA and also receiving PFCs. - verify_pause_frame_count_dut(rx_dut=rx_dut, - tx_dut=tx_dut, + verify_pause_frame_count_dut(rx_dut=ingress_duthost, + tx_dut=egress_duthost, test_traffic_pause=test_traffic_pause, global_pause=global_pause, snappi_extra_params=snappi_extra_params) # Verify in flight TX lossless packets do not leave the DUT when traffic is expected # to be paused, or leave the DUT when the traffic is not expected to be paused - verify_egress_queue_frame_count(duthost=duthost, + # Verifying the packets on DUT egress, especially for multi line card scenario + verify_egress_queue_frame_count(duthost=egress_duthost, switch_flow_stats=switch_flow_stats, test_traffic_pause=test_traffic_pause, snappi_extra_params=snappi_extra_params) if test_traffic_pause: # Verify in flight TX packets count relative to switch buffer size - verify_in_flight_buffer_pkts(egress_duthost=duthost, - ingress_duthost=duthost, + verify_in_flight_buffer_pkts(egress_duthost=egress_duthost, + ingress_duthost=ingress_duthost, flow_metrics=in_flight_flow_metrics, - snappi_extra_params=snappi_extra_params) + snappi_extra_params=snappi_extra_params, + asic_value=tx_port.get('asic_value')) else: # Verify zero pause frames are counted when the PFC class enable vector is not set verify_unset_cev_pause_frame_count(duthost=duthost, @@ -302,12 +323,118 @@ def run_pfc_test(api, if test_traffic_pause and not snappi_extra_params.gen_background_traffic: # Verify TX frame count on the DUT when traffic is expected to be paused # and only test traffic flows are generated - verify_tx_frame_count_dut(duthost=duthost, + verify_tx_frame_count_dut(duthost=egress_duthost, api=api, snappi_extra_params=snappi_extra_params) # Verify TX frame count on the DUT when traffic is expected to be paused # and only test traffic flows are generated - verify_rx_frame_count_dut(duthost=duthost, + verify_rx_frame_count_dut(duthost=ingress_duthost, api=api, snappi_extra_params=snappi_extra_params) + + +def run_tx_drop_counter( + api, + testbed_config, + port_config_list, + dut_port, + test_prio_list, + prio_dscp_map, + snappi_extra_params=None): + + pytest_assert(testbed_config is not None, 'Failed to get L2/3 testbed config') + + if snappi_extra_params is None: + snappi_extra_params = SnappiTestParams() + + rx_port = snappi_extra_params.multi_dut_params.multi_dut_ports[0] + duthost = rx_port['duthost'] + port_id = 0 + + # Generate base traffic config + snappi_extra_params.base_flow_config = setup_base_traffic_config(testbed_config=testbed_config, + port_config_list=port_config_list, + port_id=port_id) + + test_flow_rate_percent = int(TEST_FLOW_AGGR_RATE_PERCENT / len(test_prio_list)) + + # Set default traffic flow configs if not set + if snappi_extra_params.traffic_flow_config.data_flow_config is None: + snappi_extra_params.traffic_flow_config.data_flow_config = { + "flow_name": TEST_FLOW_NAME, + "flow_dur_sec": DATA_FLOW_DURATION_SEC, + "flow_rate_percent": test_flow_rate_percent, + "flow_rate_pps": None, + "flow_rate_bps": None, + "flow_pkt_size": data_flow_pkt_size, + "flow_pkt_count": None, + "flow_delay_sec": data_flow_delay_sec, + "flow_traffic_type": traffic_flow_mode.FIXED_DURATION + } + + # Generate test flow config + generate_test_flows(testbed_config=testbed_config, + test_flow_prio_list=test_prio_list, + prio_dscp_map=prio_dscp_map, + snappi_extra_params=snappi_extra_params) + + flows = testbed_config.flows + + all_flow_names = [flow.name for flow in flows] + data_flow_names = [flow.name for flow in flows if PAUSE_FLOW_NAME not in flow.name] + + duthost.command("sonic-clear counters") + duthost.command("sonic-clear queuecounters") + # Collect metrics from DUT before traffic + tx_ok_frame_count, tx_dut_drop_frames = get_tx_frame_count(duthost, dut_port) + + """ Run traffic """ + tgen_flow_stats, _, _ = run_traffic( + duthost=duthost, + api=api, + config=testbed_config, + data_flow_names=data_flow_names, + all_flow_names=all_flow_names, + exp_dur_sec=DATA_FLOW_DURATION_SEC + + data_flow_delay_sec, + snappi_extra_params=snappi_extra_params) + link_state = None + try: + time.sleep(1) + # Collect metrics from DUT once again + tx_ok_frame_count_1, tx_dut_drop_frames_1 = get_tx_frame_count(duthost, dut_port) + + pytest_assert(tx_ok_frame_count_1 > tx_ok_frame_count and tx_dut_drop_frames_1 == tx_dut_drop_frames, + "DUT Port {} : TX ok counter before {} after {}, Tx drop counter before {} after {} not expected". + format(dut_port, tx_ok_frame_count, tx_ok_frame_count_1, + tx_dut_drop_frames, tx_dut_drop_frames_1)) + + # Set port name of the Ixia port connected to dut_port + port_names = snappi_extra_params.base_flow_config["rx_port_name"] + # Create a link state object for ports + link_state = api.link_state() + # Apply the state to port + link_state.port_names = [port_names] + # Set port down (shut) + link_state.state = link_state.DOWN + api.set_link_state(link_state) + logger.info("Snappi port {} is set to DOWN".format(port_names)) + time.sleep(1) + # Collect metrics from DUT again + _, tx_dut_drop_frames = get_tx_frame_count(duthost, dut_port) + + logger.info("Sleeping for 90 seconds") + time.sleep(90) + # Collect metrics from DUT once again + _, tx_dut_drop_frames_1 = get_tx_frame_count(duthost, dut_port) + + pytest_assert(tx_dut_drop_frames == tx_dut_drop_frames_1, + "Mismatch in TX drop counters post DUT port {} oper down".format(dut_port)) + finally: + if link_state: + # Bring the link back up + link_state.state = link_state.UP + api.set_link_state(link_state) + logger.info("Snappi port {} is set to UP".format(port_names)) + return diff --git a/tests/snappi_tests/multidut/pfc/files/lossless_response_to_external_pause_storms_helper.py b/tests/snappi_tests/pfc/files/lossless_response_to_external_pause_storms_helper.py similarity index 100% rename from tests/snappi_tests/multidut/pfc/files/lossless_response_to_external_pause_storms_helper.py rename to tests/snappi_tests/pfc/files/lossless_response_to_external_pause_storms_helper.py diff --git a/tests/snappi_tests/multidut/pfc/files/lossless_response_to_throttling_pause_storms_helper.py b/tests/snappi_tests/pfc/files/lossless_response_to_throttling_pause_storms_helper.py similarity index 100% rename from tests/snappi_tests/multidut/pfc/files/lossless_response_to_throttling_pause_storms_helper.py rename to tests/snappi_tests/pfc/files/lossless_response_to_throttling_pause_storms_helper.py diff --git a/tests/snappi_tests/multidut/pfc/files/m2o_fluctuating_lossless_helper.py b/tests/snappi_tests/pfc/files/m2o_fluctuating_lossless_helper.py similarity index 100% rename from tests/snappi_tests/multidut/pfc/files/m2o_fluctuating_lossless_helper.py rename to tests/snappi_tests/pfc/files/m2o_fluctuating_lossless_helper.py diff --git a/tests/snappi_tests/multidut/pfc/files/m2o_oversubscribe_lossless_helper.py b/tests/snappi_tests/pfc/files/m2o_oversubscribe_lossless_helper.py similarity index 100% rename from tests/snappi_tests/multidut/pfc/files/m2o_oversubscribe_lossless_helper.py rename to tests/snappi_tests/pfc/files/m2o_oversubscribe_lossless_helper.py diff --git a/tests/snappi_tests/multidut/pfc/files/m2o_oversubscribe_lossless_lossy_helper.py b/tests/snappi_tests/pfc/files/m2o_oversubscribe_lossless_lossy_helper.py similarity index 100% rename from tests/snappi_tests/multidut/pfc/files/m2o_oversubscribe_lossless_lossy_helper.py rename to tests/snappi_tests/pfc/files/m2o_oversubscribe_lossless_lossy_helper.py diff --git a/tests/snappi_tests/multidut/pfc/files/m2o_oversubscribe_lossy_helper.py b/tests/snappi_tests/pfc/files/m2o_oversubscribe_lossy_helper.py similarity index 100% rename from tests/snappi_tests/multidut/pfc/files/m2o_oversubscribe_lossy_helper.py rename to tests/snappi_tests/pfc/files/m2o_oversubscribe_lossy_helper.py diff --git a/tests/snappi_tests/pfc/test_global_pause_with_snappi.py b/tests/snappi_tests/pfc/test_global_pause_with_snappi.py index 1ebdbfb6913..8bbd3e81ec2 100644 --- a/tests/snappi_tests/pfc/test_global_pause_with_snappi.py +++ b/tests/snappi_tests/pfc/test_global_pause_with_snappi.py @@ -1,66 +1,96 @@ import pytest +import logging +from tests.common.helpers.assertions import pytest_require, pytest_assert # noqa: F401 +from tests.common.fixtures.conn_graph_facts import conn_graph_facts, fanout_graph_facts, \ + fanout_graph_facts_multidut # noqa: F401 +from tests.common.snappi_tests.snappi_fixtures import snappi_api_serv_ip, snappi_api_serv_port, \ + snappi_api, get_snappi_ports, is_snappi_multidut, \ + get_snappi_ports_single_dut, snappi_testbed_config, \ + get_snappi_ports_multi_dut, snappi_dut_base_config, cleanup_config, get_snappi_ports_for_rdma # noqa: F401 +from tests.common.snappi_tests.qos_fixtures import lossless_prio_list, prio_dscp_map, disable_pfcwd # noqa: F401 +from tests.snappi_tests.pfc.files.helper import run_pfc_test # noqa: F401 +from tests.common.snappi_tests.snappi_test_params import SnappiTestParams +from tests.snappi_tests.variables import MULTIDUT_PORT_INFO, MULTIDUT_TESTBED -from tests.common.helpers.assertions import pytest_require -from tests.common.fixtures.conn_graph_facts import conn_graph_facts,\ - fanout_graph_facts # noqa F401 -from tests.common.snappi_tests.snappi_fixtures import snappi_api_serv_ip, snappi_api_serv_port,\ - snappi_api, snappi_testbed_config # noqa F401 -from tests.common.snappi_tests.qos_fixtures import prio_dscp_map, all_prio_list, lossless_prio_list,\ - lossy_prio_list # noqa F401 +logger = logging.getLogger(__name__) -from tests.snappi_tests.pfc.files.helper import run_pfc_test +pytestmark = [pytest.mark.topology('multidut-tgen', 'tgen')] -pytestmark = [pytest.mark.topology('tgen')] - -def test_global_pause(snappi_api, # noqa F811 - snappi_testbed_config, # noqa F811 - conn_graph_facts, # noqa F811 - fanout_graph_facts, # noqa F811 +@pytest.mark.parametrize("multidut_port_info", MULTIDUT_PORT_INFO[MULTIDUT_TESTBED]) +def test_global_pause(snappi_api, # noqa: F811 + conn_graph_facts, # noqa: F811 + fanout_graph_facts_multidut, # noqa: F811 + get_snappi_ports, # noqa: F811 duthosts, - rand_one_dut_hostname, - rand_one_dut_portname_oper_up, - lossless_prio_list, # noqa F811 - lossy_prio_list, # noqa F811 - prio_dscp_map): # noqa F811 + prio_dscp_map, # noqa: F811 + lossless_prio_list, # noqa: F811 + tbinfo, # noqa: F811 + multidut_port_info, + disable_pfcwd): # noqa: F811 """ Test if IEEE 802.3X pause (a.k.a., global pause) will impact any priority Args: snappi_api (pytest fixture): SNAPPI session - snappi_testbed_config (pytest fixture): testbed configuration information conn_graph_facts (pytest fixture): connection graph - fanout_graph_facts (pytest fixture): fanout graph + fanout_graph_facts_multidut (pytest fixture): fanout graph for multiple duts + get_snappi_ports (pytest fixture): list of snappi port and duthost information duthosts (pytest fixture): list of DUTs - rand_one_dut_hostname (str): hostname of DUT - rand_one_dut_portname_oper_up (str): name of port to test, e.g., 's6100-1|Ethernet0' lossless_prio_list (pytest fixture): list of all the lossless priorities - lossy_prio_list (pytest fixture): list of all the lossy priorities prio_dscp_map (pytest fixture): priority vs. DSCP map (key = priority). - + tbinfo (pytest fixture): fixture provides information about testbed + get_snappi_ports (pytest fixture): gets snappi ports and connected DUT port info and returns as a list Returns: N/A """ + snappi_port_list = get_snappi_ports + + tbname = tbinfo.get('conf-name', None) + + tx_port_count = 1 + rx_port_count = 1 - dut_hostname, dut_port = rand_one_dut_portname_oper_up.split('|') - pytest_require(rand_one_dut_hostname == dut_hostname, - "Port is not mapped to the expected DUT") + pytest_assert(len(snappi_port_list) >= tx_port_count + rx_port_count, + "Need Minimum of 2 ports defined in ansible/files/*links.csv file") - testbed_config, port_config_list = snappi_testbed_config - duthost = duthosts[rand_one_dut_hostname] + for testbed_subtype, rdma_ports in multidut_port_info.items(): + pytest_assert(len(rdma_ports['tx_ports']) >= tx_port_count, + 'MULTIDUT_PORT_INFO doesn\'t have the required Tx ports defined for \ + testbed {}, subtype {} in variables.py'. + format(MULTIDUT_TESTBED, testbed_subtype)) + + pytest_assert(len(rdma_ports['rx_ports']) >= rx_port_count, + 'MULTIDUT_PORT_INFO doesn\'t have the required Rx ports defined for \ + testbed {}, subtype {} in variables.py'. + format(tbname, testbed_subtype)) + logger.info('Running test for testbed subtype: {}'.format(testbed_subtype)) + if is_snappi_multidut(duthosts): + snappi_ports = get_snappi_ports_for_rdma(snappi_port_list, rdma_ports, + tx_port_count, rx_port_count, MULTIDUT_TESTBED) + else: + snappi_ports = snappi_port_list + testbed_config, port_config_list, snappi_ports = snappi_dut_base_config(duthosts, + snappi_ports, + snappi_api) + + all_prio_list = prio_dscp_map.keys() test_prio_list = lossless_prio_list - bg_prio_list = lossy_prio_list + bg_prio_list = [x for x in all_prio_list if x not in test_prio_list] + snappi_extra_params = SnappiTestParams() + snappi_extra_params.multi_dut_params.multi_dut_ports = snappi_ports run_pfc_test(api=snappi_api, testbed_config=testbed_config, port_config_list=port_config_list, conn_data=conn_graph_facts, - fanout_data=fanout_graph_facts, - duthost=duthost, - dut_port=dut_port, + fanout_data=fanout_graph_facts_multidut, global_pause=True, pause_prio_list=None, test_prio_list=test_prio_list, bg_prio_list=bg_prio_list, prio_dscp_map=prio_dscp_map, - test_traffic_pause=False) + test_traffic_pause=False, + snappi_extra_params=snappi_extra_params) + + cleanup_config(duthosts, snappi_ports) diff --git a/tests/snappi_tests/multidut/pfc/test_lossless_response_to_external_pause_storms.py b/tests/snappi_tests/pfc/test_lossless_response_to_external_pause_storms.py similarity index 98% rename from tests/snappi_tests/multidut/pfc/test_lossless_response_to_external_pause_storms.py rename to tests/snappi_tests/pfc/test_lossless_response_to_external_pause_storms.py index 1241de71c90..31768440ab1 100644 --- a/tests/snappi_tests/multidut/pfc/test_lossless_response_to_external_pause_storms.py +++ b/tests/snappi_tests/pfc/test_lossless_response_to_external_pause_storms.py @@ -9,7 +9,7 @@ from tests.common.snappi_tests.qos_fixtures import prio_dscp_map, \ lossless_prio_list, disable_pfcwd # noqa: F401 from tests.snappi_tests.files.helper import multidut_port_info, setup_ports_and_dut, reboot_duts # noqa: F401 -from tests.snappi_tests.multidut.pfc.files.lossless_response_to_external_pause_storms_helper import ( +from tests.snappi_tests.pfc.files.lossless_response_to_external_pause_storms_helper import ( run_lossless_response_to_external_pause_storms_test, ) from tests.common.snappi_tests.snappi_test_params import SnappiTestParams diff --git a/tests/snappi_tests/multidut/pfc/test_lossless_response_to_throttling_pause_storms.py b/tests/snappi_tests/pfc/test_lossless_response_to_throttling_pause_storms.py similarity index 98% rename from tests/snappi_tests/multidut/pfc/test_lossless_response_to_throttling_pause_storms.py rename to tests/snappi_tests/pfc/test_lossless_response_to_throttling_pause_storms.py index a535178c656..f1e5d6b6053 100644 --- a/tests/snappi_tests/multidut/pfc/test_lossless_response_to_throttling_pause_storms.py +++ b/tests/snappi_tests/pfc/test_lossless_response_to_throttling_pause_storms.py @@ -8,7 +8,7 @@ snappi_api, snappi_dut_base_config, get_snappi_ports, get_snappi_ports_for_rdma, cleanup_config # noqa: F401 from tests.common.snappi_tests.qos_fixtures import prio_dscp_map, \ lossless_prio_list, disable_pfcwd # noqa: F401 -from tests.snappi_tests.multidut.pfc.files.lossless_response_to_throttling_pause_storms_helper import ( +from tests.snappi_tests.pfc.files.lossless_response_to_throttling_pause_storms_helper import ( run_lossless_response_to_throttling_pause_storms_test) from tests.common.snappi_tests.snappi_test_params import SnappiTestParams from tests.snappi_tests.files.helper import setup_ports_and_dut, multidut_port_info # noqa: F401 diff --git a/tests/snappi_tests/multidut/pfc/test_m2o_fluctuating_lossless.py b/tests/snappi_tests/pfc/test_m2o_fluctuating_lossless.py similarity index 96% rename from tests/snappi_tests/multidut/pfc/test_m2o_fluctuating_lossless.py rename to tests/snappi_tests/pfc/test_m2o_fluctuating_lossless.py index c1c66acea59..bcd410a98a8 100644 --- a/tests/snappi_tests/multidut/pfc/test_m2o_fluctuating_lossless.py +++ b/tests/snappi_tests/pfc/test_m2o_fluctuating_lossless.py @@ -9,10 +9,10 @@ from tests.common.snappi_tests.qos_fixtures import prio_dscp_map, \ lossless_prio_list, disable_pfcwd # noqa: F401 from tests.snappi_tests.files.helper import multidut_port_info, setup_ports_and_dut # noqa: F401 -from tests.snappi_tests.multidut.pfc.files.m2o_fluctuating_lossless_helper import run_m2o_fluctuating_lossless_test +from tests.snappi_tests.pfc.files.m2o_fluctuating_lossless_helper import run_m2o_fluctuating_lossless_test from tests.common.snappi_tests.snappi_test_params import SnappiTestParams logger = logging.getLogger(__name__) -pytestmark = [pytest.mark.topology('multidut-tgen', 'tgen')] +pytestmark = [pytest.mark.topology('multidut-tgen')] @pytest.fixture(autouse=True) diff --git a/tests/snappi_tests/multidut/pfc/test_m2o_oversubscribe_lossless.py b/tests/snappi_tests/pfc/test_m2o_oversubscribe_lossless.py similarity index 98% rename from tests/snappi_tests/multidut/pfc/test_m2o_oversubscribe_lossless.py rename to tests/snappi_tests/pfc/test_m2o_oversubscribe_lossless.py index 001801dd856..d940590f581 100644 --- a/tests/snappi_tests/multidut/pfc/test_m2o_oversubscribe_lossless.py +++ b/tests/snappi_tests/pfc/test_m2o_oversubscribe_lossless.py @@ -8,7 +8,7 @@ snappi_api, snappi_dut_base_config, get_snappi_ports, get_snappi_ports_for_rdma, cleanup_config # noqa: F401 from tests.common.snappi_tests.qos_fixtures import prio_dscp_map, \ lossless_prio_list, disable_pfcwd # noqa: F401 -from tests.snappi_tests.multidut.pfc.files.m2o_oversubscribe_lossless_helper import ( +from tests.snappi_tests.pfc.files.m2o_oversubscribe_lossless_helper import ( run_m2o_oversubscribe_lossless_test ) from tests.common.snappi_tests.snappi_test_params import SnappiTestParams diff --git a/tests/snappi_tests/multidut/pfc/test_m2o_oversubscribe_lossless_lossy.py b/tests/snappi_tests/pfc/test_m2o_oversubscribe_lossless_lossy.py similarity index 98% rename from tests/snappi_tests/multidut/pfc/test_m2o_oversubscribe_lossless_lossy.py rename to tests/snappi_tests/pfc/test_m2o_oversubscribe_lossless_lossy.py index f9255a21679..5355e97e68e 100644 --- a/tests/snappi_tests/multidut/pfc/test_m2o_oversubscribe_lossless_lossy.py +++ b/tests/snappi_tests/pfc/test_m2o_oversubscribe_lossless_lossy.py @@ -8,7 +8,7 @@ snappi_api, snappi_dut_base_config, get_snappi_ports, get_snappi_ports_for_rdma, cleanup_config # noqa: F401 from tests.common.snappi_tests.qos_fixtures import prio_dscp_map, \ lossless_prio_list, disable_pfcwd # noqa: F401 -from tests.snappi_tests.multidut.pfc.files.m2o_oversubscribe_lossless_lossy_helper import ( +from tests.snappi_tests.pfc.files.m2o_oversubscribe_lossless_lossy_helper import ( run_pfc_m2o_oversubscribe_lossless_lossy_test ) # noqa: F401 from tests.common.snappi_tests.snappi_test_params import SnappiTestParams # noqa: F401 diff --git a/tests/snappi_tests/multidut/pfc/test_m2o_oversubscribe_lossy.py b/tests/snappi_tests/pfc/test_m2o_oversubscribe_lossy.py similarity index 96% rename from tests/snappi_tests/multidut/pfc/test_m2o_oversubscribe_lossy.py rename to tests/snappi_tests/pfc/test_m2o_oversubscribe_lossy.py index 8e62e705175..c57ee1d4255 100644 --- a/tests/snappi_tests/multidut/pfc/test_m2o_oversubscribe_lossy.py +++ b/tests/snappi_tests/pfc/test_m2o_oversubscribe_lossy.py @@ -8,11 +8,11 @@ snappi_api, snappi_dut_base_config, get_snappi_ports, get_snappi_ports_for_rdma, cleanup_config # noqa: F401 from tests.common.snappi_tests.qos_fixtures import prio_dscp_map, \ lossless_prio_list, disable_pfcwd # noqa: F401 -from tests.snappi_tests.multidut.pfc.files.m2o_oversubscribe_lossy_helper import run_pfc_m2o_oversubscribe_lossy_test +from tests.snappi_tests.pfc.files.m2o_oversubscribe_lossy_helper import run_pfc_m2o_oversubscribe_lossy_test from tests.common.snappi_tests.snappi_test_params import SnappiTestParams from tests.snappi_tests.files.helper import setup_ports_and_dut, multidut_port_info # noqa: F401 logger = logging.getLogger(__name__) -pytestmark = [pytest.mark.topology('multidut-tgen', 'tgen')] +pytestmark = [pytest.mark.topology('multidut-tgen')] @pytest.fixture(autouse=True) diff --git a/tests/snappi_tests/pfc/test_pfc_mixed_speed.py b/tests/snappi_tests/pfc/test_pfc_mixed_speed.py index 3848d25f045..2a1c8741cd9 100644 --- a/tests/snappi_tests/pfc/test_pfc_mixed_speed.py +++ b/tests/snappi_tests/pfc/test_pfc_mixed_speed.py @@ -6,7 +6,7 @@ snappi_api, cleanup_config, get_snappi_ports_for_rdma, snappi_multi_base_config, \ get_snappi_ports, get_snappi_ports_multi_dut, clear_fabric_counters, check_fabric_counters # noqa: F401 from tests.common.snappi_tests.qos_fixtures import prio_dscp_map, lossless_prio_list, \ - lossy_prio_list, all_prio_list # noqa: F401 + lossy_prio_list, all_prio_list, disable_pfcwd # noqa: F401 from tests.snappi_tests.variables import MIXED_SPEED_PORT_INFO, MULTIDUT_TESTBED from tests.snappi_tests.pfc.files.mixed_speed_multidut_helper import run_pfc_test from tests.common.snappi_tests.snappi_test_params import SnappiTestParams @@ -33,7 +33,8 @@ def test_mixed_speed_diff_dist_over(snappi_api, # noqa: F811 tbinfo, get_snappi_ports, # noqa: F811 port_map, - multidut_port_info): # noqa: F811 + multidut_port_info, # noqa: F811 + disable_pfcwd): # noqa: F811 """ Majority traffic is lossless priority traffic. @@ -169,7 +170,8 @@ def test_mixed_speed_uni_dist_over(snappi_api, # noqa: F811 tbinfo, get_snappi_ports, # noqa: F811 port_map, - multidut_port_info): # noqa: F811 + multidut_port_info, # noqa: F811 + disable_pfcwd): # noqa: F811 """ Traffic is sent to IXIA receiver in equal amount. @@ -303,7 +305,8 @@ def test_mixed_speed_no_congestion(snappi_api, # noqa: F811 tbinfo, get_snappi_ports, # noqa: F811 port_map, - multidut_port_info): # noqa: F811 + multidut_port_info, # noqa: F811 + disable_pfcwd): # noqa: F811 """ Test to have mixed speed ingress and egress without oversubscribing the egress. diff --git a/tests/snappi_tests/pfc/test_pfc_no_congestion_throughput.py b/tests/snappi_tests/pfc/test_pfc_no_congestion_throughput.py index 3f2825e5622..d656fb1df22 100644 --- a/tests/snappi_tests/pfc/test_pfc_no_congestion_throughput.py +++ b/tests/snappi_tests/pfc/test_pfc_no_congestion_throughput.py @@ -6,7 +6,7 @@ snappi_api, cleanup_config, get_snappi_ports_for_rdma, snappi_multi_base_config, \ get_snappi_ports, get_snappi_ports_multi_dut, clear_fabric_counters, check_fabric_counters # noqa: F401 from tests.common.snappi_tests.qos_fixtures import prio_dscp_map, lossless_prio_list, \ - lossy_prio_list, all_prio_list # noqa: F401 + lossy_prio_list, all_prio_list, disable_pfcwd # noqa: F401 from tests.snappi_tests.pfc.files.pfc_congestion_helper import run_pfc_test from tests.common.snappi_tests.snappi_test_params import SnappiTestParams from tests.snappi_tests.variables import MULTIDUT_PORT_INFO, MULTIDUT_TESTBED @@ -34,7 +34,8 @@ def test_multiple_prio_diff_dist(snappi_api, # noqa: F811 tbinfo, get_snappi_ports, # noqa: F811 port_map, - multidut_port_info): # noqa: F811 + multidut_port_info, + disable_pfcwd): # noqa: F811 """ Purpose of the test is to check if line-rate can be achieved. @@ -174,7 +175,8 @@ def test_multiple_prio_uni_dist(snappi_api, # noqa: F811 tbinfo, get_snappi_ports, # noqa: F811 port_map, - multidut_port_info): # noqa: F811 + multidut_port_info, + disable_pfcwd): # noqa: F811 """ Purpose of the test is to check if line-rate can be achieved. @@ -315,7 +317,8 @@ def test_single_lossless_prio(snappi_api, # noqa: F811 tbinfo, get_snappi_ports, # noqa: F811 port_map, - multidut_port_info): # noqa: F811 + multidut_port_info, + disable_pfcwd): # noqa: F811 """ Purpose of the test is to check if line-rate can be achieved with single priority traffic. diff --git a/tests/snappi_tests/pfc/test_pfc_pause_lossless_with_snappi.py b/tests/snappi_tests/pfc/test_pfc_pause_lossless_with_snappi.py index dcccd48af13..18b22b97a20 100644 --- a/tests/snappi_tests/pfc/test_pfc_pause_lossless_with_snappi.py +++ b/tests/snappi_tests/pfc/test_pfc_pause_lossless_with_snappi.py @@ -1,136 +1,141 @@ -import logging import pytest - -from tests.snappi_tests.pfc.files.helper import run_pfc_test -from tests.common.helpers.assertions import pytest_assert, pytest_require -from tests.common.fixtures.conn_graph_facts import conn_graph_facts,\ - fanout_graph_facts # noqa F401 -from tests.common.snappi_tests.snappi_fixtures import snappi_api_serv_ip, snappi_api_serv_port,\ - snappi_api, snappi_testbed_config # noqa F401 +from tests.common.helpers.assertions import pytest_require, pytest_assert # noqa: F401 +from tests.common.fixtures.conn_graph_facts import conn_graph_facts, fanout_graph_facts, \ + fanout_graph_facts_multidut # noqa: F401 +from tests.common.snappi_tests.snappi_fixtures import snappi_api_serv_ip, snappi_api_serv_port, \ + snappi_api, snappi_dut_base_config, get_snappi_ports_for_rdma, cleanup_config, get_snappi_ports_multi_dut, \ + snappi_testbed_config, get_snappi_ports_single_dut, \ + get_snappi_ports, is_snappi_multidut # noqa: F401 +from tests.snappi_tests.files.helper import multidut_port_info, setup_ports_and_dut, reboot_duts # noqa: F401 from tests.common.snappi_tests.qos_fixtures import prio_dscp_map, all_prio_list, lossless_prio_list,\ - lossy_prio_list # noqa F401 -from tests.common.reboot import reboot -from tests.common.platform.processes_utils import wait_critical_processes -from tests.common.utilities import wait_until -from tests.snappi_tests.files.helper import skip_warm_reboot + lossy_prio_list, disable_pfcwd # noqa F401 +from tests.snappi_tests.pfc.files.helper import run_pfc_test +import logging from tests.common.snappi_tests.snappi_test_params import SnappiTestParams + logger = logging.getLogger(__name__) -pytestmark = [pytest.mark.topology('tgen')] +pytestmark = [pytest.mark.topology('multidut-tgen', 'tgen')] + +@pytest.fixture(autouse=True) +def number_of_tx_rx_ports(): + yield (1, 1) -def test_pfc_pause_single_lossless_prio(snappi_api, # noqa F811 - snappi_testbed_config, # noqa F811 - conn_graph_facts, # noqa F811 - fanout_graph_facts, # noqa F811 + +def test_pfc_pause_single_lossless_prio(snappi_api, # noqa: F811 + conn_graph_facts, # noqa: F811 + fanout_graph_facts_multidut, # noqa: F811 duthosts, - rand_one_dut_hostname, - rand_one_dut_portname_oper_up, - enum_dut_lossless_prio, - all_prio_list, # noqa F811 - prio_dscp_map): # noqa F811 + enum_one_dut_lossless_prio, + prio_dscp_map, # noqa: F811 + lossless_prio_list, # noqa: F811 + all_prio_list, # noqa: F811 + get_snappi_ports, # noqa: F811 + tbinfo, # noqa: F811 + disable_pfcwd, # noqa: F811 + setup_ports_and_dut): # noqa: F811 + """ - Test if PFC can pause a single lossless priority + Test if PFC can pause a single lossless priority in multidut setup Args: snappi_api (pytest fixture): SNAPPI session - snappi_testbed_config (pytest fixture): testbed configuration information conn_graph_facts (pytest fixture): connection graph - fanout_graph_facts (pytest fixture): fanout graph + fanout_graph_facts_multidut (pytest fixture): fanout graph duthosts (pytest fixture): list of DUTs - rand_one_dut_hostname (str): hostname of DUT - rand_one_dut_portname_oper_up (str): port to test, e.g., 's6100-1|Ethernet0' enum_dut_lossless_prio (str): lossless priority to test, e.g., 's6100-1|3' all_prio_list (pytest fixture): list of all the priorities prio_dscp_map (pytest fixture): priority vs. DSCP map (key = priority). + lossless_prio_list (pytest fixture): list of all the lossless priorities + tbinfo (pytest fixture): fixture provides information about testbed + get_snappi_ports (pytest fixture): gets snappi ports and connected DUT port info and returns as a list Returns: N/A """ - dut_hostname, dut_port = rand_one_dut_portname_oper_up.split('|') - dut_hostname2, lossless_prio = enum_dut_lossless_prio.split('|') - pytest_require(rand_one_dut_hostname == dut_hostname == dut_hostname2, - "Priority and port are not mapped to the expected DUT") + testbed_config, port_config_list, snappi_ports = setup_ports_and_dut - testbed_config, port_config_list = snappi_testbed_config - duthost = duthosts[rand_one_dut_hostname] + _, lossless_prio = enum_one_dut_lossless_prio.split('|') lossless_prio = int(lossless_prio) - pause_prio_list = [lossless_prio] test_prio_list = [lossless_prio] bg_prio_list = [p for p in all_prio_list] bg_prio_list.remove(lossless_prio) + logger.info("Snappi Ports : {}".format(snappi_ports)) + + snappi_extra_params = SnappiTestParams() + snappi_extra_params.multi_dut_params.multi_dut_ports = snappi_ports + run_pfc_test(api=snappi_api, testbed_config=testbed_config, port_config_list=port_config_list, conn_data=conn_graph_facts, - fanout_data=fanout_graph_facts, - duthost=duthost, - dut_port=dut_port, + fanout_data=fanout_graph_facts_multidut, global_pause=False, pause_prio_list=pause_prio_list, test_prio_list=test_prio_list, bg_prio_list=bg_prio_list, prio_dscp_map=prio_dscp_map, - test_traffic_pause=True) + test_traffic_pause=True, + snappi_extra_params=snappi_extra_params) -def test_pfc_pause_counter_check(snappi_api, # noqa F811 - snappi_testbed_config, # noqa F811 - conn_graph_facts, # noqa F811 - fanout_graph_facts, # noqa F811 + +def test_pfc_pause_counter_check(snappi_api, # noqa: F811 + conn_graph_facts, # noqa: F811 + fanout_graph_facts_multidut, # noqa: F811 duthosts, - rand_one_dut_hostname, - rand_one_dut_portname_oper_up, - enum_dut_lossless_prio, - all_prio_list, # noqa F811 - prio_dscp_map): # noqa F811 + enum_one_dut_lossless_prio, + prio_dscp_map, # noqa: F811 + lossless_prio_list, # noqa: F811 + all_prio_list, # noqa: F811 + get_snappi_ports, # noqa: F811 + tbinfo, # noqa: F811 + disable_pfcwd, # noqa: F811 + setup_ports_and_dut): # noqa F811 """ Test if PFC pause frames are counted properly by the DUT. This test is slightly different to the other PFC pause tests. We will only send lossless prio packets i.e. no background traffic. Args: snappi_api (pytest fixture): SNAPPI session - snappi_testbed_config (pytest fixture): testbed configuration information conn_graph_facts (pytest fixture): connection graph - fanout_graph_facts (pytest fixture): fanout graph + fanout_graph_facts_multidut (pytest fixture): fanout graph duthosts (pytest fixture): list of DUTs - rand_one_dut_hostname (str): hostname of DUT - rand_one_dut_portname_oper_up (str): port to test, e.g., 's6100-1|Ethernet0' enum_dut_lossless_prio (str): lossless priority to test, e.g., 's6100-1|3' all_prio_list (pytest fixture): list of all the priorities prio_dscp_map (pytest fixture): priority vs. DSCP map (key = priority). + lossless_prio_list (pytest fixture): list of all the lossless priorities + tbinfo (pytest fixture): fixture provides information about testbed + get_snappi_ports (pytest fixture): gets snappi ports and connected DUT port info and returns as a list Returns: N/A """ - dut_hostname, dut_port = rand_one_dut_portname_oper_up.split('|') - dut_hostname2, lossless_prio = enum_dut_lossless_prio.split('|') - pytest_require(rand_one_dut_hostname == dut_hostname == dut_hostname2, - "Priority and port are not mapped to the expected DUT") + testbed_config, port_config_list, snappi_ports = setup_ports_and_dut - testbed_config, port_config_list = snappi_testbed_config - duthost = duthosts[rand_one_dut_hostname] + _, lossless_prio = enum_one_dut_lossless_prio.split('|') lossless_prio = int(lossless_prio) - pause_prio_list = [lossless_prio] test_prio_list = [lossless_prio] bg_prio_list = [p for p in all_prio_list] bg_prio_list.remove(lossless_prio) + logger.info("Snappi Ports : {}".format(snappi_ports)) + snappi_extra_params = SnappiTestParams() + snappi_extra_params.multi_dut_params.multi_dut_ports = snappi_ports snappi_extra_params.gen_background_traffic = False run_pfc_test(api=snappi_api, testbed_config=testbed_config, port_config_list=port_config_list, conn_data=conn_graph_facts, - fanout_data=fanout_graph_facts, - duthost=duthost, - dut_port=dut_port, + fanout_data=fanout_graph_facts_multidut, global_pause=False, pause_prio_list=pause_prio_list, test_prio_list=test_prio_list, @@ -139,200 +144,169 @@ def test_pfc_pause_counter_check(snappi_api, # noqa F811 test_traffic_pause=True, snappi_extra_params=snappi_extra_params) -def test_pfc_pause_multi_lossless_prio(snappi_api, # noqa F811 - snappi_testbed_config, # noqa F811 - conn_graph_facts, # noqa F811 - fanout_graph_facts, # noqa F811 + +def test_pfc_pause_multi_lossless_prio(snappi_api, # noqa: F811 + conn_graph_facts, # noqa: F811 + fanout_graph_facts_multidut, # noqa: F811 duthosts, - rand_one_dut_hostname, - rand_one_dut_portname_oper_up, - lossless_prio_list, # noqa F811 - lossy_prio_list, # noqa F811 - prio_dscp_map): # noqa F811 + prio_dscp_map, # noqa: F811 + lossy_prio_list, # noqa: F811 + lossless_prio_list, # noqa: F811 + get_snappi_ports, # noqa: F811 + tbinfo, + disable_pfcwd, # noqa: F811 + setup_ports_and_dut): # noqa: F811 + """ - Test if PFC can pause multiple lossless priorities + Test if PFC can pause multiple lossless priorities in multidut setup Args: snappi_api (pytest fixture): SNAPPI session - snappi_testbed_config (pytest fixture): testbed configuration information conn_graph_facts (pytest fixture): connection graph - fanout_graph_facts (pytest fixture): fanout graph + fanout_graph_facts_multidut (pytest fixture): fanout graph duthosts (pytest fixture): list of DUTs - rand_one_dut_hostname (str): hostname of DUT - rand_one_dut_portname_oper_up (str): port to test, e.g., 's6100-1|Ethernet0' + prio_dscp_map (pytest fixture): priority vs. DSCP map (key = priority). lossless_prio_list (pytest fixture): list of all the lossless priorities lossy_prio_list (pytest fixture): list of all the lossy priorities - prio_dscp_map (pytest fixture): priority vs. DSCP map (key = priority). - + tbinfo (pytest fixture): fixture provides information about testbed + get_snappi_ports (pytest fixture): gets snappi ports and connected DUT port info and returns as a list Returns: N/A """ + testbed_config, port_config_list, snappi_ports = setup_ports_and_dut - dut_hostname, dut_port = rand_one_dut_portname_oper_up.split('|') - pytest_require(rand_one_dut_hostname == dut_hostname, - "Port is not mapped to the expected DUT") - - testbed_config, port_config_list = snappi_testbed_config - duthost = duthosts[rand_one_dut_hostname] pause_prio_list = lossless_prio_list test_prio_list = lossless_prio_list bg_prio_list = lossy_prio_list + logger.info("Snappi Ports : {}".format(snappi_ports)) + + snappi_extra_params = SnappiTestParams() + snappi_extra_params.multi_dut_params.multi_dut_ports = snappi_ports run_pfc_test(api=snappi_api, testbed_config=testbed_config, port_config_list=port_config_list, conn_data=conn_graph_facts, - fanout_data=fanout_graph_facts, - duthost=duthost, - dut_port=dut_port, + fanout_data=fanout_graph_facts_multidut, global_pause=False, pause_prio_list=pause_prio_list, test_prio_list=test_prio_list, bg_prio_list=bg_prio_list, prio_dscp_map=prio_dscp_map, - test_traffic_pause=True) + test_traffic_pause=True, + snappi_extra_params=snappi_extra_params) @pytest.mark.disable_loganalyzer -@pytest.mark.parametrize('reboot_type', ['warm', 'cold', 'fast']) -def test_pfc_pause_single_lossless_prio_reboot(snappi_api, # noqa F811 - snappi_testbed_config, # noqa F811 - conn_graph_facts, # noqa F811 - fanout_graph_facts, # noqa F811 - localhost, +def test_pfc_pause_single_lossless_prio_reboot(snappi_api, # noqa: F811 + conn_graph_facts, # noqa: F811 + fanout_graph_facts_multidut, # noqa: F811 duthosts, - rand_one_dut_hostname, - rand_one_dut_portname_oper_up, - rand_lossless_prio, - all_prio_list, # noqa F811 - prio_dscp_map, # noqa F811 - reboot_type): + localhost, + enum_one_dut_lossless_prio_with_completeness_level, # noqa: F811 + prio_dscp_map, # noqa: F811 + lossless_prio_list, # noqa: F811 + all_prio_list, # noqa: F811 + get_snappi_ports, # noqa: F811 + tbinfo, # noqa: F811 + setup_ports_and_dut, # noqa: F811 + disable_pfcwd, # noqa: F811 + reboot_duts): # noqa: F811 """ - Test if PFC can pause a single lossless priority even after various types of reboot + Test if PFC can pause a single lossless priority even after various types of reboot in multidut setup Args: snappi_api (pytest fixture): SNAPPI session - snappi_testbed_config (pytest fixture): testbed configuration information conn_graph_facts (pytest fixture): connection graph - fanout_graph_facts (pytest fixture): fanout graph - localhost (pytest fixture): localhost handle + fanout_graph_facts_multidut (pytest fixture): fanout graph duthosts (pytest fixture): list of DUTs - rand_one_dut_hostname (str): hostname of DUT - rand_one_dut_portname_oper_up (str): port to test, e.g., 's6100-1|Ethernet0' - rand_lossless_prio (str): lossless priority to test, e.g., 's6100-1|3' + localhost (pytest fixture): localhost handle + enum_dut_lossless_prio_with_completeness_level (str): lossless priority to test, e.g., 's6100-1|3' all_prio_list (pytest fixture): list of all the priorities prio_dscp_map (pytest fixture): priority vs. DSCP map (key = priority). - reboot_type (str): reboot type to be issued on the DUT - + lossless_prio_list (pytest fixture): list of all the lossless priorities + tbinfo (pytest fixture): fixture provides information about testbed + get_snappi_ports (pytest fixture): gets snappi ports and connected DUT port info and returns as a list Returns: N/A """ + testbed_config, port_config_list, snappi_ports = setup_ports_and_dut - dut_hostname, dut_port = rand_one_dut_portname_oper_up.split('|') - dut_hostname2, lossless_prio = rand_lossless_prio.split('|') - pytest_require(rand_one_dut_hostname == dut_hostname == dut_hostname2, - "Priority and port are not mapped to the expected DUT") - - testbed_config, port_config_list = snappi_testbed_config - duthost = duthosts[rand_one_dut_hostname] - - skip_warm_reboot(duthost, reboot_type) - + _, lossless_prio = enum_one_dut_lossless_prio_with_completeness_level.split('|') lossless_prio = int(lossless_prio) pause_prio_list = [lossless_prio] test_prio_list = [lossless_prio] bg_prio_list = [p for p in all_prio_list] bg_prio_list.remove(lossless_prio) + logger.info("Snappi Ports : {}".format(snappi_ports)) - logger.info("Issuing a {} reboot on the dut {}".format( - reboot_type, duthost.hostname)) - reboot(duthost, localhost, reboot_type=reboot_type, safe_reboot=True) - logger.info("Wait until the system is stable") - wait_critical_processes(duthost) - pytest_assert(wait_until(300, 20, 0, duthost.critical_services_fully_started), - "Not all critical services are fully started") + snappi_extra_params = SnappiTestParams() + snappi_extra_params.multi_dut_params.multi_dut_ports = snappi_ports run_pfc_test(api=snappi_api, testbed_config=testbed_config, port_config_list=port_config_list, conn_data=conn_graph_facts, - fanout_data=fanout_graph_facts, - duthost=duthost, - dut_port=dut_port, + fanout_data=fanout_graph_facts_multidut, global_pause=False, pause_prio_list=pause_prio_list, test_prio_list=test_prio_list, bg_prio_list=bg_prio_list, prio_dscp_map=prio_dscp_map, - test_traffic_pause=True) + test_traffic_pause=True, + snappi_extra_params=snappi_extra_params) @pytest.mark.disable_loganalyzer -@pytest.mark.parametrize('reboot_type', ['warm', 'cold', 'fast']) -def test_pfc_pause_multi_lossless_prio_reboot(snappi_api, # noqa F811 - snappi_testbed_config, # noqa F811 - conn_graph_facts, # noqa F811 - fanout_graph_facts, # noqa F811 - localhost, +def test_pfc_pause_multi_lossless_prio_reboot(snappi_api, # noqa: F811 + conn_graph_facts, # noqa: F811 + fanout_graph_facts_multidut, # noqa: F811 duthosts, - rand_one_dut_hostname, - rand_one_dut_portname_oper_up, - lossless_prio_list, # noqa F811 - lossy_prio_list, # noqa F811 - prio_dscp_map, # noqa F811 - reboot_type): + localhost, + prio_dscp_map, # noqa: F811 + lossy_prio_list, # noqa: F811 + lossless_prio_list, # noqa: F811 + get_snappi_ports, # noqa: F811 + tbinfo, # noqa: F811 + setup_ports_and_dut, # noqa: F811 + disable_pfcwd, # noqa: F811 + reboot_duts): # noqa: F811 """ - Test if PFC can pause multiple lossless priorities even after various types of reboot + Test if PFC can pause multiple lossless priorities even after various types of reboot in multidut setup Args: snappi_api (pytest fixture): SNAPPI session - snappi_testbed_config (pytest fixture): testbed configuration information conn_graph_facts (pytest fixture): connection graph - fanout_graph_facts (pytest fixture): fanout graph - localhost (pytest fixture): localhost handle + fanout_graph_facts_multidut (pytest fixture): fanout graph duthosts (pytest fixture): list of DUTs - rand_one_dut_hostname (str): hostname of DUT - rand_one_dut_portname_oper_up (str): port to test, e.g., 's6100-1|Ethernet0' + localhost (pytest fixture): localhost handle + prio_dscp_map (pytest fixture): priority vs. DSCP map (key = priority). lossless_prio_list (pytest fixture): list of all the lossless priorities lossy_prio_list (pytest fixture): list of all the lossy priorities - prio_dscp_map (pytest fixture): priority vs. DSCP map (key = priority). - reboot_type (str): reboot type to be issued on the DUT - + tbinfo (pytest fixture): fixture provides information about testbed + get_snappi_ports (pytest fixture): gets snappi ports and connected DUT port info and returns as a list Returns: N/A """ - - dut_hostname, dut_port = rand_one_dut_portname_oper_up.split('|') - pytest_require(rand_one_dut_hostname == dut_hostname, - "Port is not mapped to the expected DUT") - - testbed_config, port_config_list = snappi_testbed_config - duthost = duthosts[rand_one_dut_hostname] - - skip_warm_reboot(duthost, reboot_type) + testbed_config, port_config_list, snappi_ports = setup_ports_and_dut pause_prio_list = lossless_prio_list test_prio_list = lossless_prio_list bg_prio_list = lossy_prio_list + logger.info("Snappi Ports : {}".format(snappi_ports)) - logger.info("Issuing a {} reboot on the dut {}".format( - reboot_type, duthost.hostname)) - reboot(duthost, localhost, reboot_type=reboot_type, safe_reboot=True) - logger.info("Wait until the system is stable") - wait_critical_processes(duthost) - pytest_assert(wait_until(300, 20, 0, duthost.critical_services_fully_started), - "Not all critical services are fully started") + snappi_extra_params = SnappiTestParams() + snappi_extra_params.multi_dut_params.multi_dut_ports = snappi_ports run_pfc_test(api=snappi_api, testbed_config=testbed_config, port_config_list=port_config_list, conn_data=conn_graph_facts, - fanout_data=fanout_graph_facts, - duthost=duthost, - dut_port=dut_port, + fanout_data=fanout_graph_facts_multidut, global_pause=False, pause_prio_list=pause_prio_list, test_prio_list=test_prio_list, bg_prio_list=bg_prio_list, prio_dscp_map=prio_dscp_map, - test_traffic_pause=True) + test_traffic_pause=True, + snappi_extra_params=snappi_extra_params) diff --git a/tests/snappi_tests/pfc/test_pfc_pause_lossy_with_snappi.py b/tests/snappi_tests/pfc/test_pfc_pause_lossy_with_snappi.py index 2ba052ca54f..b4afe1248a8 100644 --- a/tests/snappi_tests/pfc/test_pfc_pause_lossy_with_snappi.py +++ b/tests/snappi_tests/pfc/test_pfc_pause_lossy_with_snappi.py @@ -1,221 +1,229 @@ -import logging import pytest - -from tests.snappi_tests.pfc.files.helper import run_pfc_test -from tests.common.helpers.assertions import pytest_assert, pytest_require -from tests.common.fixtures.conn_graph_facts import conn_graph_facts,\ - fanout_graph_facts # noqa F401 -from tests.common.snappi_tests.snappi_fixtures import snappi_api_serv_ip, snappi_api_serv_port,\ - snappi_api, snappi_testbed_config # noqa F401 +from tests.common.helpers.assertions import pytest_require, pytest_assert # noqa: F401 +from tests.common.fixtures.conn_graph_facts import conn_graph_facts, fanout_graph_facts, \ + fanout_graph_facts_multidut # noqa: F401 +from tests.common.snappi_tests.snappi_fixtures import snappi_api_serv_ip, snappi_api_serv_port, \ + snappi_api, snappi_dut_base_config, get_snappi_ports_for_rdma, cleanup_config, \ + get_snappi_ports_single_dut, snappi_testbed_config, \ + get_snappi_ports_multi_dut, is_snappi_multidut, \ + get_snappi_ports # noqa: F401 from tests.common.snappi_tests.qos_fixtures import prio_dscp_map, all_prio_list, lossless_prio_list,\ lossy_prio_list # noqa F401 -from tests.common.reboot import reboot -from tests.common.utilities import wait_until -from tests.snappi_tests.files.helper import skip_warm_reboot - +from tests.snappi_tests.variables import MULTIDUT_PORT_INFO, MULTIDUT_TESTBED # noqa: F401 +from tests.snappi_tests.pfc.files.helper import run_pfc_test +import logging +from tests.common.snappi_tests.snappi_test_params import SnappiTestParams +from tests.snappi_tests.files.helper import reboot_duts, setup_ports_and_dut, multidut_port_info # noqa: F401 logger = logging.getLogger(__name__) -pytestmark = [pytest.mark.topology('tgen')] +pytestmark = [pytest.mark.topology('multidut-tgen', 'tgen')] + +@pytest.fixture(autouse=True) +def number_of_tx_rx_ports(): + yield (1, 1) -def test_pfc_pause_single_lossy_prio(snappi_api, # noqa F811 - snappi_testbed_config, # noqa F811 - conn_graph_facts, # noqa F811 - fanout_graph_facts, # noqa F811 + +def test_pfc_pause_single_lossy_prio(snappi_api, # noqa: F811 + conn_graph_facts, # noqa: F811 + fanout_graph_facts_multidut, # noqa: F811 duthosts, - rand_one_dut_hostname, - rand_one_dut_portname_oper_up, - enum_dut_lossy_prio, - all_prio_list, # noqa F811 - prio_dscp_map): # noqa F811 + enum_one_dut_lossy_prio, + prio_dscp_map, # noqa: F811 + lossy_prio_list, # noqa: F811 + all_prio_list, # noqa: F811 + lossless_prio_list, # noqa: F811 + get_snappi_ports, # noqa: F811 + tbinfo, # noqa: F811 + setup_ports_and_dut # noqa: F811 + ): """ - Test if PFC will impact a single lossy priority + Test if PFC will impact a single lossy priority in multidut setup Args: snappi_api (pytest fixture): SNAPPI session - snappi_testbed_config (pytest fixture): testbed configuration information conn_graph_facts (pytest fixture): connection graph - fanout_graph_facts (pytest fixture): fanout graph + fanout_graph_facts_multidut (pytest fixture): fanout graph duthosts (pytest fixture): list of DUTs - rand_one_dut_hostname (str): hostname of DUT - rand_one_dut_portname_oper_up (str): port to test, e.g., 's6100-1|Ethernet0' enum_dut_lossy_prio (str): name of lossy priority to test, e.g., 's6100-1|2' - all_prio_list (pytest fixture): list of all the priorities prio_dscp_map (pytest fixture): priority vs. DSCP map (key = priority). + lossy_prio_list (pytest fixture): list of all the lossy priorities + all_prio_list (pytest fixture): list of all the priorities + lossy_prio_list (pytest fixture): list of all the lossy priorities + Returns: N/A """ + testbed_config, port_config_list, snappi_ports = setup_ports_and_dut - dut_hostname, dut_port = rand_one_dut_portname_oper_up.split('|') - dut_hostname2, lossy_prio = enum_dut_lossy_prio.split('|') - pytest_require(rand_one_dut_hostname == dut_hostname == dut_hostname2, - "Priority and port are not mapped to the expected DUT") - - testbed_config, port_config_list = snappi_testbed_config - duthost = duthosts[rand_one_dut_hostname] + _, lossy_prio = enum_one_dut_lossy_prio.split('|') lossy_prio = int(lossy_prio) - pause_prio_list = [lossy_prio] test_prio_list = [lossy_prio] bg_prio_list = [p for p in all_prio_list] bg_prio_list.remove(lossy_prio) + snappi_extra_params = SnappiTestParams() + snappi_extra_params.multi_dut_params.multi_dut_ports = snappi_ports + + flow_factor = 1 + + if snappi_ports[0]['asic_type'] == 'cisco-8000' and int(snappi_ports[0]['speed']) > 200000: + flow_factor = int(snappi_ports[0]['speed']) / 200000 + run_pfc_test(api=snappi_api, testbed_config=testbed_config, port_config_list=port_config_list, conn_data=conn_graph_facts, - fanout_data=fanout_graph_facts, - duthost=duthost, - dut_port=dut_port, + fanout_data=fanout_graph_facts_multidut, global_pause=False, pause_prio_list=pause_prio_list, test_prio_list=test_prio_list, bg_prio_list=bg_prio_list, prio_dscp_map=prio_dscp_map, - test_traffic_pause=False) + test_traffic_pause=False, + test_flow_is_lossless=False, + snappi_extra_params=snappi_extra_params, + flow_factor=flow_factor) -def test_pfc_pause_multi_lossy_prio(snappi_api, # noqa F811 - snappi_testbed_config, # noqa F811 - conn_graph_facts, # noqa F811 - fanout_graph_facts, # noqa F811 +def test_pfc_pause_multi_lossy_prio(snappi_api, # noqa: F811 + conn_graph_facts, # noqa: F811 + fanout_graph_facts_multidut, # noqa: F811 duthosts, - rand_one_dut_hostname, - rand_one_dut_portname_oper_up, - lossless_prio_list, # noqa F811 - lossy_prio_list, # noqa F811 - prio_dscp_map): # noqa F811 + prio_dscp_map, # noqa: F811 + lossy_prio_list, # noqa: F811 + lossless_prio_list, # noqa: F811 + get_snappi_ports, # noqa: F811 + tbinfo, # noqa: F811 + setup_ports_and_dut): # noqa: F811 """ - Test if PFC will impact multiple lossy priorities + Test if PFC will impact multiple lossy priorities in multidut setup Args: snappi_api (pytest fixture): SNAPPI session - snappi_testbed_config (pytest fixture): testbed configuration information conn_graph_facts (pytest fixture): connection graph - fanout_graph_facts (pytest fixture): fanout graph + fanout_graph_facts_multidut (pytest fixture): fanout graph duthosts (pytest fixture): list of DUTs - rand_one_dut_hostname (str): hostname of DUT - rand_one_dut_portname_oper_up (str): port to test, e.g., 's6100-1|Ethernet0' + prio_dscp_map (pytest fixture): priority vs. DSCP map (key = priority). lossless_prio_list (pytest fixture): list of all the lossless priorities lossy_prio_list (pytest fixture): list of all the lossy priorities - prio_dscp_map (pytest fixture): priority vs. DSCP map (key = priority). - + tbinfo (pytest fixture): fixture provides information about testbed + get_snappi_ports (pytest fixture): gets snappi ports and connected DUT port info and returns as a list Returns: N/A """ + testbed_config, port_config_list, snappi_ports = setup_ports_and_dut - dut_hostname, dut_port = rand_one_dut_portname_oper_up.split('|') - pytest_require(rand_one_dut_hostname == dut_hostname, - "Port is not mapped to the expected DUT") - - testbed_config, port_config_list = snappi_testbed_config - duthost = duthosts[rand_one_dut_hostname] pause_prio_list = lossy_prio_list test_prio_list = lossy_prio_list bg_prio_list = lossless_prio_list + snappi_extra_params = SnappiTestParams() + snappi_extra_params.multi_dut_params.multi_dut_ports = snappi_ports + + flow_factor = 1 + + if snappi_ports[0]['asic_type'] == 'cisco-8000' and int(snappi_ports[0]['speed']) > 200000: + flow_factor = int(snappi_ports[0]['speed']) / 200000 + run_pfc_test(api=snappi_api, testbed_config=testbed_config, port_config_list=port_config_list, conn_data=conn_graph_facts, - fanout_data=fanout_graph_facts, - duthost=duthost, - dut_port=dut_port, + fanout_data=fanout_graph_facts_multidut, global_pause=False, pause_prio_list=pause_prio_list, test_prio_list=test_prio_list, bg_prio_list=bg_prio_list, prio_dscp_map=prio_dscp_map, - test_traffic_pause=False) + test_traffic_pause=False, + test_flow_is_lossless=False, + snappi_extra_params=snappi_extra_params, + flow_factor=flow_factor) @pytest.mark.disable_loganalyzer -@pytest.mark.parametrize('reboot_type', ['warm', 'cold', 'fast']) -def test_pfc_pause_single_lossy_prio_reboot(snappi_api, # noqa F811 - snappi_testbed_config, # noqa F811 - conn_graph_facts, # noqa F811 - fanout_graph_facts, # noqa F811 - localhost, +def test_pfc_pause_single_lossy_prio_reboot(snappi_api, # noqa: F811 + conn_graph_facts, # noqa: F811 + fanout_graph_facts_multidut, # noqa: F811 duthosts, - rand_one_dut_hostname, - rand_one_dut_portname_oper_up, - rand_lossy_prio, - all_prio_list, # noqa F811 - prio_dscp_map, # noqa F811 - reboot_type): + localhost, + enum_one_dut_lossy_prio_with_completeness_level, + prio_dscp_map, # noqa: F811 + lossy_prio_list, # noqa: F811 + all_prio_list, # noqa: F811 + lossless_prio_list, # noqa: F811 + get_snappi_ports, # noqa: F811 + tbinfo, # noqa: F811 + setup_ports_and_dut, # noqa: F811 + reboot_duts): # noqa: F811 """ - Test if PFC will impact a single lossy priority after various kinds of reboots + Test if PFC will impact a single lossy priority after various kinds of reboots in multidut setup Args: snappi_api (pytest fixture): SNAPPI session - snappi_testbed_config (pytest fixture): testbed configuration information conn_graph_facts (pytest fixture): connection graph - fanout_graph_facts (pytest fixture): fanout graph - localhost (pytest fixture): localhost handle + fanout_graph_facts_multidut (pytest fixture): fanout graph duthosts (pytest fixture): list of DUTs - rand_one_dut_hostname (str): hostname of DUT - rand_one_dut_portname_oper_up (str): port to test, e.g., 's6100-1|Ethernet0' - rand_lossy_prio (str): lossy priority to test, e.g., 's6100-1|2' - all_prio_list (pytest fixture): list of all the priorities + localhost (pytest fixture): localhost handle + enum_dut_lossy_prio_with_completeness_level (str): name of lossy priority to test, e.g., 's6100-1|2' prio_dscp_map (pytest fixture): priority vs. DSCP map (key = priority). + lossy_prio_list (pytest fixture): list of all the lossy priorities + all_prio_list (pytest fixture): list of all the priorities reboot_type (str): reboot type to be issued on the DUT - + tbinfo (pytest fixture): fixture provides information about testbed + get_snappi_ports (pytest fixture): gets snappi ports and connected DUT port info and returns as a list Returns: N/A """ + testbed_config, port_config_list, snappi_ports = setup_ports_and_dut - dut_hostname, dut_port = rand_one_dut_portname_oper_up.split('|') - dut_hostname2, lossy_prio = rand_lossy_prio.split('|') - pytest_require(rand_one_dut_hostname == dut_hostname == dut_hostname2, - "Priority and port are not mapped to the expected DUT") - - duthost = duthosts[rand_one_dut_hostname] - skip_warm_reboot(duthost, reboot_type) - testbed_config, port_config_list = snappi_testbed_config + _, lossy_prio = enum_one_dut_lossy_prio_with_completeness_level.split('|') lossy_prio = int(lossy_prio) - pause_prio_list = [lossy_prio] test_prio_list = [lossy_prio] bg_prio_list = [p for p in all_prio_list] bg_prio_list.remove(lossy_prio) - logger.info("Issuing a {} reboot on the dut {}".format( - reboot_type, duthost.hostname)) - reboot(duthost, localhost, reboot_type=reboot_type, safe_reboot=True) - logger.info("Wait until the system is stable") - pytest_assert(wait_until(300, 20, 0, duthost.critical_services_fully_started), - "Not all critical services are fully started") + snappi_extra_params = SnappiTestParams() + snappi_extra_params.multi_dut_params.multi_dut_ports = snappi_ports + + flow_factor = 1 + + if snappi_ports[0]['asic_type'] == 'cisco-8000' and int(snappi_ports[0]['speed']) > 200000: + flow_factor = int(snappi_ports[0]['speed']) / 200000 run_pfc_test(api=snappi_api, testbed_config=testbed_config, port_config_list=port_config_list, conn_data=conn_graph_facts, - fanout_data=fanout_graph_facts, - duthost=duthost, - dut_port=dut_port, + fanout_data=fanout_graph_facts_multidut, global_pause=False, pause_prio_list=pause_prio_list, test_prio_list=test_prio_list, bg_prio_list=bg_prio_list, prio_dscp_map=prio_dscp_map, - test_traffic_pause=False) + test_traffic_pause=False, + test_flow_is_lossless=False, + snappi_extra_params=snappi_extra_params, + flow_factor=flow_factor) @pytest.mark.disable_loganalyzer -@pytest.mark.parametrize('reboot_type', ['warm', 'cold', 'fast']) -def test_pfc_pause_multi_lossy_prio_reboot(snappi_api, # noqa F811 - snappi_testbed_config, # noqa F811 - conn_graph_facts, # noqa F811 - fanout_graph_facts, # noqa F811 - localhost, +def test_pfc_pause_multi_lossy_prio_reboot(snappi_api, # noqa: F811 + conn_graph_facts, # noqa: F811 + fanout_graph_facts_multidut, # noqa: F811 duthosts, - rand_one_dut_hostname, - rand_one_dut_portname_oper_up, - lossless_prio_list, # noqa F811 - lossy_prio_list, # noqa F811 - prio_dscp_map, # noqa F811 - reboot_type): + localhost, + prio_dscp_map, # noqa: F811 + lossy_prio_list, # noqa: F811 + lossless_prio_list, # noqa: F811 + get_snappi_ports, # noqa: F811 + tbinfo, # noqa: F811 + setup_ports_and_dut, # noqa: F811 + reboot_duts): # noqa: F811 """ Test if PFC will impact multiple lossy priorities after various kinds of reboots @@ -223,50 +231,43 @@ def test_pfc_pause_multi_lossy_prio_reboot(snappi_api, # noqa F snappi_api (pytest fixture): SNAPPI session snappi_testbed_config (pytest fixture): testbed configuration information conn_graph_facts (pytest fixture): connection graph - fanout_graph_facts (pytest fixture): fanout graph + fanout_graph_facts_multidut (pytest fixture): fanout graph localhost (pytest fixture): localhost handle duthosts (pytest fixture): list of DUTs - rand_one_dut_hostname (str): hostname of DUT - rand_one_dut_portname_oper_up (str): port to test, e.g., 's6100-1|Ethernet0' + prio_dscp_map (pytest fixture): priority vs. DSCP map (key = priority). lossless_prio_list (pytest fixture): list of all the lossless priorities lossy_prio_list (pytest fixture): list of all the lossy priorities - prio_dscp_map (pytest fixture): priority vs. DSCP map (key = priority). reboot_type (str): reboot type to be issued on the DUT - + tbinfo (pytest fixture): fixture provides information about testbed + get_snappi_ports (pytest fixture): gets snappi ports and connected DUT port info and returns as a list Returns: N/A """ - - dut_hostname, dut_port = rand_one_dut_portname_oper_up.split('|') - pytest_require(rand_one_dut_hostname == dut_hostname, - "Port is not mapped to the expected DUT") - - testbed_config, port_config_list = snappi_testbed_config - duthost = duthosts[rand_one_dut_hostname] - - skip_warm_reboot(duthost, reboot_type) + testbed_config, port_config_list, snappi_ports = setup_ports_and_dut pause_prio_list = lossy_prio_list test_prio_list = lossy_prio_list bg_prio_list = lossless_prio_list - logger.info("Issuing a {} reboot on the dut {}".format( - reboot_type, duthost.hostname)) - reboot(duthost, localhost, reboot_type=reboot_type, safe_reboot=True) - logger.info("Wait until the system is stable") - pytest_assert(wait_until(300, 20, 0, duthost.critical_services_fully_started), - "Not all critical services are fully started") + snappi_extra_params = SnappiTestParams() + snappi_extra_params.multi_dut_params.multi_dut_ports = snappi_ports + + flow_factor = 1 + + if snappi_ports[0]['asic_type'] == 'cisco-8000' and int(snappi_ports[0]['speed']) > 200000: + flow_factor = int(snappi_ports[0]['speed']) / 200000 run_pfc_test(api=snappi_api, testbed_config=testbed_config, port_config_list=port_config_list, conn_data=conn_graph_facts, - fanout_data=fanout_graph_facts, - duthost=duthost, - dut_port=dut_port, + fanout_data=fanout_graph_facts_multidut, global_pause=False, pause_prio_list=pause_prio_list, test_prio_list=test_prio_list, bg_prio_list=bg_prio_list, prio_dscp_map=prio_dscp_map, - test_traffic_pause=False) + test_traffic_pause=False, + test_flow_is_lossless=False, + snappi_extra_params=snappi_extra_params, + flow_factor=flow_factor) diff --git a/tests/snappi_tests/pfc/test_pfc_pause_response_with_snappi.py b/tests/snappi_tests/pfc/test_pfc_pause_response_with_snappi.py index 36b5c540cbf..dc9fcdd6936 100644 --- a/tests/snappi_tests/pfc/test_pfc_pause_response_with_snappi.py +++ b/tests/snappi_tests/pfc/test_pfc_pause_response_with_snappi.py @@ -8,7 +8,7 @@ from tests.common.snappi_tests.snappi_fixtures import snappi_api_serv_ip, snappi_api_serv_port,\ snappi_api, snappi_testbed_config # noqa F401 from tests.common.snappi_tests.qos_fixtures import prio_dscp_map, all_prio_list, lossless_prio_list,\ - lossy_prio_list # noqa F401 + lossy_prio_list, disable_pfcwd # noqa F401 from tests.common.snappi_tests.snappi_test_params import SnappiTestParams logger = logging.getLogger(__name__) @@ -26,7 +26,8 @@ def test_pfc_single_lossless_headroom(snappi_api, # noqa F enum_dut_lossless_prio, all_prio_list, # noqa F811 prio_dscp_map, # noqa F811 - enum_pfc_pause_delay_test_params): + enum_pfc_pause_delay_test_params, + disable_pfcwd): # noqa F811 """ Test headroom capacity for DUT for a single lossless priority @@ -99,7 +100,8 @@ def test_pfc_pause_multi_lossless_headroom(snappi_api, # noqa F lossless_prio_list, # noqa F811 lossy_prio_list, # noqa F811 prio_dscp_map, # noqa F811 - enum_pfc_pause_delay_test_params): + enum_pfc_pause_delay_test_params, + disable_pfcwd): # noqa F811 """ Test headroom capacity for DUT for multiple lossless priorities diff --git a/tests/snappi_tests/pfc/test_pfc_pause_unset_bit_enable_vector.py b/tests/snappi_tests/pfc/test_pfc_pause_unset_bit_enable_vector.py index 554e84a9800..e9b2931bc34 100644 --- a/tests/snappi_tests/pfc/test_pfc_pause_unset_bit_enable_vector.py +++ b/tests/snappi_tests/pfc/test_pfc_pause_unset_bit_enable_vector.py @@ -8,7 +8,7 @@ from tests.common.snappi_tests.snappi_fixtures import snappi_api_serv_ip, snappi_api_serv_port,\ snappi_api, snappi_testbed_config # noqa F401 from tests.common.snappi_tests.qos_fixtures import prio_dscp_map, all_prio_list, lossless_prio_list,\ - lossy_prio_list # noqa F401 + lossy_prio_list, disable_pfcwd # noqa F401 from tests.common.snappi_tests.snappi_test_params import SnappiTestParams logger = logging.getLogger(__name__) @@ -25,7 +25,8 @@ def test_pfc_unset_cev_single_prio(snappi_api, # noqa F811 rand_one_dut_portname_oper_up, enum_dut_lossless_prio, all_prio_list, # noqa F811 - prio_dscp_map): # noqa F811 + prio_dscp_map, # noqa F811 + disable_pfcwd): # noqa F811 """ Test if PFC frames with no bit set in the class enable vector are ignored by the DUT for a single lossless priority @@ -85,7 +86,8 @@ def test_pfc_unset_cev_multi_prio(snappi_api, # noqa F811 rand_one_dut_portname_oper_up, lossless_prio_list, # noqa F811 lossy_prio_list, # noqa F811 - prio_dscp_map): # noqa F811 + prio_dscp_map, # noqa F811 + disable_pfcwd): # noqa F811 """ Test if PFC frames with no bit set in the class enable vector are ignored by the DUT for multiple lossless priorities diff --git a/tests/snappi_tests/pfc/test_pfc_pause_zero_mac.py b/tests/snappi_tests/pfc/test_pfc_pause_zero_mac.py index 66573b9a88f..68e0b3309c6 100644 --- a/tests/snappi_tests/pfc/test_pfc_pause_zero_mac.py +++ b/tests/snappi_tests/pfc/test_pfc_pause_zero_mac.py @@ -8,7 +8,7 @@ from tests.common.snappi_tests.snappi_fixtures import snappi_api_serv_ip, snappi_api_serv_port,\ snappi_api, snappi_testbed_config # noqa F401 from tests.common.snappi_tests.qos_fixtures import prio_dscp_map, all_prio_list, lossless_prio_list,\ - lossy_prio_list # noqa F401 + lossy_prio_list, disable_pfcwd # noqa F401 from tests.common.snappi_tests.snappi_test_params import SnappiTestParams logger = logging.getLogger(__name__) @@ -25,7 +25,8 @@ def test_pfc_zero_src_mac_single_lossless_prio(snappi_api, # noqa F811 rand_one_dut_portname_oper_up, enum_dut_lossless_prio, all_prio_list, # noqa F811 - prio_dscp_map): # noqa F811 + prio_dscp_map, # noqa F811 + disable_pfcwd): # noqa F811 """ Test if PFC pause frames with zero source MAC address are counted by the DUT for a single lossless priority @@ -88,7 +89,8 @@ def test_pfc_zero_src_mac_multi_lossless_prio(snappi_api, # noqa F811 rand_one_dut_portname_oper_up, lossless_prio_list, # noqa F811 lossy_prio_list, # noqa F811 - prio_dscp_map): # noqa F811 + prio_dscp_map, # noqa F811 + disable_pfcwd): # noqa F811 """ Test if PFC pause frames with zero source MAC address are counted by the DUT for multiple lossless priorities diff --git a/tests/snappi_tests/pfc/test_pfc_port_congestion.py b/tests/snappi_tests/pfc/test_pfc_port_congestion.py index 2008ce6c95c..9ca1cdc12ed 100644 --- a/tests/snappi_tests/pfc/test_pfc_port_congestion.py +++ b/tests/snappi_tests/pfc/test_pfc_port_congestion.py @@ -6,7 +6,7 @@ snappi_api, snappi_multi_base_config, cleanup_config, get_snappi_ports_for_rdma, \ get_snappi_ports, get_snappi_ports_multi_dut, clear_fabric_counters, check_fabric_counters # noqa: F401 from tests.common.snappi_tests.qos_fixtures import prio_dscp_map, lossless_prio_list, \ - lossy_prio_list, all_prio_list # noqa: F401 + lossy_prio_list, all_prio_list, disable_pfcwd # noqa: F401 from tests.snappi_tests.variables import MULTIDUT_PORT_INFO, MULTIDUT_TESTBED from tests.snappi_tests.pfc.files.pfc_congestion_helper import run_pfc_test from tests.common.snappi_tests.snappi_test_params import SnappiTestParams @@ -36,7 +36,8 @@ def test_multiple_prio_diff_dist(snappi_api, # noqa: F811 tbinfo, get_snappi_ports, # noqa: F811 port_map, - multidut_port_info): # noqa: F811 + multidut_port_info, # noqa: F811 + disable_pfcwd): # noqa: F811 """ Purpose of the test case is to test oversubscription with two ingresses and single ingress. @@ -172,7 +173,8 @@ def test_multiple_prio_uni_dist(snappi_api, # noqa: F811 tbinfo, get_snappi_ports, # noqa: F811 port_map, - multidut_port_info): # noqa: F811 + multidut_port_info, # noqa: F811 + disable_pfcwd): # noqa: F811 """ Purpose of the test case is to test oversubscription with two ingresses and single ingress. Traffic pattern has 24% lossless priority and 36% lossy priority traffic. @@ -307,7 +309,8 @@ def test_multiple_prio_equal_dist(snappi_api, # noqa: F811 tbinfo, get_snappi_ports, # noqa: F811 port_map, - multidut_port_info): # noqa: F811 + multidut_port_info, # noqa: F811 + disable_pfcwd): # noqa: F811 """ Purpose of the test case is to test oversubscription with two ingresses and single ingress. @@ -444,7 +447,8 @@ def test_multiple_prio_non_cngtn(snappi_api, # noqa: F811 tbinfo, get_snappi_ports, # noqa: F811 port_map, - multidut_port_info): # noqa: F811 + multidut_port_info, # noqa: F811 + disable_pfcwd): # noqa: F811 """ Purpose of the test case is to test oversubscription with two ingresses and single ingress. diff --git a/tests/snappi_tests/multidut/pfc/test_tx_drop_counter_with_snappi.py b/tests/snappi_tests/pfc/test_tx_drop_counter_with_snappi.py similarity index 92% rename from tests/snappi_tests/multidut/pfc/test_tx_drop_counter_with_snappi.py rename to tests/snappi_tests/pfc/test_tx_drop_counter_with_snappi.py index a4baa17e558..de817f9a3b7 100644 --- a/tests/snappi_tests/multidut/pfc/test_tx_drop_counter_with_snappi.py +++ b/tests/snappi_tests/pfc/test_tx_drop_counter_with_snappi.py @@ -9,8 +9,8 @@ snappi_testbed_config, get_snappi_ports_single_dut, \ get_snappi_ports, is_snappi_multidut # noqa F401 from tests.common.snappi_tests.qos_fixtures import prio_dscp_map, \ - lossless_prio_list # noqa F401 -from tests.snappi_tests.multidut.pfc.files.multidut_helper import run_tx_drop_counter + lossless_prio_list, disable_pfcwd # noqa F401 +from tests.snappi_tests.pfc.files.helper import run_tx_drop_counter from tests.common.snappi_tests.snappi_test_params import SnappiTestParams from tests.snappi_tests.files.helper import multidut_port_info, setup_ports_and_dut # noqa: F401 @@ -27,7 +27,8 @@ def test_tx_drop_counter( snappi_api, # noqa F811 lossless_prio_list, # noqa F811 prio_dscp_map,# noqa F811 - setup_ports_and_dut # noqa F811 + setup_ports_and_dut, # noqa F811 + disable_pfcwd # noqa F811 ): """ Test if device under test (DUT) is incrementing diff --git a/tests/snappi_tests/pfc/test_valid_pfc_frame_with_snappi.py b/tests/snappi_tests/pfc/test_valid_pfc_frame_with_snappi.py index c0339cfd3cc..ec978552a16 100644 --- a/tests/snappi_tests/pfc/test_valid_pfc_frame_with_snappi.py +++ b/tests/snappi_tests/pfc/test_valid_pfc_frame_with_snappi.py @@ -8,7 +8,7 @@ from tests.common.snappi_tests.snappi_fixtures import snappi_api_serv_ip, snappi_api_serv_port,\ snappi_api, snappi_testbed_config # noqa F401 from tests.common.snappi_tests.qos_fixtures import prio_dscp_map, all_prio_list, lossless_prio_list,\ - lossy_prio_list # noqa F401 + lossy_prio_list, disable_pfcwd # noqa F401 from tests.common.snappi_tests.snappi_test_params import SnappiTestParams from tests.common.snappi_tests.common_helpers import packet_capture @@ -25,7 +25,8 @@ def test_valid_pfc_frame(snappi_api, # noqa F811 rand_one_dut_portname_oper_up, lossless_prio_list, # noqa F811 lossy_prio_list, # noqa F811 - prio_dscp_map): # noqa F811 + prio_dscp_map, # noqa F811 + disable_pfcwd): # noqa F811 """ Test if PFC Pause frame generated by device under test (DUT) is valid. diff --git a/tests/snappi_tests/pfc/test_valid_src_mac_pfc_frame.py b/tests/snappi_tests/pfc/test_valid_src_mac_pfc_frame.py index fddc0408ee5..179d01d4d88 100644 --- a/tests/snappi_tests/pfc/test_valid_src_mac_pfc_frame.py +++ b/tests/snappi_tests/pfc/test_valid_src_mac_pfc_frame.py @@ -9,7 +9,7 @@ from tests.common.snappi_tests.snappi_fixtures import snappi_api_serv_ip, snappi_api_serv_port,\ snappi_api, snappi_testbed_config, is_snappi_multidut # noqa F401 from tests.common.snappi_tests.qos_fixtures import prio_dscp_map, all_prio_list, lossless_prio_list,\ - lossy_prio_list # noqa F401 + lossy_prio_list, disable_pfcwd # noqa F401 from tests.common.snappi_tests.snappi_test_params import SnappiTestParams from tests.common.snappi_tests.common_helpers import packet_capture from tests.common.cisco_data import is_cisco_device @@ -28,7 +28,8 @@ def test_valid_pfc_frame_src_mac( rand_one_dut_hostname, rand_one_dut_portname_oper_up, lossless_prio_list, # noqa F811 - prio_dscp_map): # noqa F811 + prio_dscp_map, # noqa F811 + disable_pfcwd): # noqa F811 """ Test if PFC Pause frame generated by device under test (DUT) is having a valid src mac