diff --git a/tests/e2e/basic/performance_tests/AX_capacity/wpa2_personal/test_bridge_eap.py b/tests/e2e/basic/performance_tests/AX_capacity/wpa2_personal/test_bridge_eap.py new file mode 100644 index 000000000..153201aae --- /dev/null +++ b/tests/e2e/basic/performance_tests/AX_capacity/wpa2_personal/test_bridge_eap.py @@ -0,0 +1,690 @@ +""" + Performance Test: AX Capacity Test : BRIDGE Mode + pytest -m "wifi_capacity_ax_tests and wpa2_enterprise and bridge" +""" +import pytest +import allure + +pytestmark = [pytest.mark.bridge, pytest.mark.wifi_capacity_ax_tests, pytest.mark.wpa2_enterprise] +setup_params_general_2G = { + "mode": "BRIDGE", + "ssid_modes": { + "wpa2_enterprise": [ + {"ssid_name": "ssid_wpa2_2g_eap", "appliedRadios": ["2G"], "security_key": "something"} + ] + }, + "rf": { + "2G": { + "band": "2G", + "channel-width": 20, + "channel": 6 + } + }, + "radius": True +} + + +@allure.feature("Performance Test") +@allure.parent_suite("AX Capacity Test") +@allure.suite("2.4 GHz Band") +@allure.sub_suite("BRIDGE Mode") +@pytest.mark.channel_6 +@pytest.mark.parametrize( + 'setup_configuration', + [setup_params_general_2G], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_configuration") +@pytest.mark.twog +class TestWifiCapacityBRIDGEModeEnterpriseAX2G(object): + @allure.testcase(url="https://telecominfraproject.atlassian.net/browse/WIFI-14240", name="WIFI-14240") + @pytest.mark.tcp_download + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + @allure.title("Single Enterprise AX client TCP Download wifi capacity") + def test_client_wpa2_bridge_tcp_dl(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in Bridge mode. + This test focuses on stressing the DUT's capacity under the influence of 2.4GHz TCP Download traffic. + The 2.4GHz station is configured for 20MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and bridge and twog and tcp_download + """ + profile_data = {"ssid_name": "ssid_wpa2_2g_eap","security_key": "something","appliedRadios": ["2G"],} + ssid_name = profile_data["ssid_name"] + mode = "BRIDGE" + security = "wpa2" + band = "twog" + eap = "TTLS" + # Pre-test cleanup to ensure a clean state + get_test_library.pre_cleanup() + + passes, result = get_test_library.enterprise_client_connectivity_test( + ssid=ssid_name, + security=security, + mode=mode, + band=band, + eap=eap, + ttls_passwd="password", + identity="testing", + num_sta=1, + dut_data=setup_configuration, + cleanup=False, + ax_enabled=True, + ) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_eap_bridge_tcp_dl_eap", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="TCP", upload_rate="56Kbps", download_rate="10Gbps", + num_stations={"2G": 1}, mode="BRIDGE") + assert True + + @allure.testcase(url="https://telecominfraproject.atlassian.net/browse/WIFI-14243", name="WIFI-14243") + @pytest.mark.udp_download + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + @allure.title("Single Enterprise AX client UDP Download wifi capacity") + def test_client_wpa2_bridge_udp_dl(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in Bridge mode. + This test focuses on stressing the DUT's capacity under the influence of 2.4GHz UDP Download traffic. + The 2.4GHz station is configured for 20MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and bridge and twog and udp_download + """ + profile_data = {"ssid_name": "ssid_wpa2_2g_eap","security_key": "something","appliedRadios": ["2G"],} + ssid_name = profile_data["ssid_name"] + mode = "BRIDGE" + security = "wpa2" + band = "twog" + eap = "TTLS" + # Pre-test cleanup to ensure a clean state + get_test_library.pre_cleanup() + + passes, result = get_test_library.enterprise_client_connectivity_test( + ssid=ssid_name, + security=security, + mode=mode, + band=band, + eap=eap, + ttls_passwd="password", + identity="testing", + num_sta=1, + dut_data=setup_configuration, + cleanup=False, + ax_enabled=True, + ) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_bridge_udp_dl", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="UDP", upload_rate="56Kbps", download_rate="10Gbps", + num_stations={"2G": 1}, mode="BRIDGE") + assert True + + @allure.testcase(url="https://telecominfraproject.atlassian.net/browse/WIFI-6940", name="WIFI-6940") + @pytest.mark.tcp_bidirectional + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + @allure.title("Single Enterprise AX client TCP Bidirectional wifi capacity") + def test_client_wpa2_bridge_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in Bridge mode. + This test focuses on stressing the DUT's capacity under the influence of 2.4GHz TCP Download and Upload traffic. + The 2.4GHz station is configured for 20MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and bridge and twog and tcp_bidirectional + """ + profile_data = {"ssid_name": "ssid_wpa2_2g_eap","security_key": "something","appliedRadios": ["2G"],} + ssid_name = profile_data["ssid_name"] + mode = "BRIDGE" + security = "wpa2" + band = "twog" + eap = "TTLS" + + # Pre-test cleanup to ensure a clean state + get_test_library.pre_cleanup() + + passes, result = get_test_library.enterprise_client_connectivity_test( + ssid=ssid_name, + security=security, + mode=mode, + band=band, + eap=eap, + ttls_passwd="password", + identity="testing", + num_sta=1, + dut_data=setup_configuration, + cleanup=False, + ax_enabled=True, + ) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_bridge_tcp_bidirectional", + dut_data=setup_configuration, + dut_mode=dut_mode, + protocol="TCP", upload_rate="10Gbps", download_rate="10Gbps", + num_stations={"2G": 1}, mode="BRIDGE") + assert True + + @allure.testcase(url="https://telecominfraproject.atlassian.net/browse/WIFI-6940", name="WIFI-6940") + @pytest.mark.udp_bidirectional + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + @allure.title("Single Enterprise AX client UDP Bidirectional wifi capacity") + def test_client_wpa2_bridge_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in Bridge mode. + This test focuses on stressing the DUT's capacity under the influence of 2.4GHz UDP Download and Upload traffic. + The 2.4GHz station is configured for 20MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and bridge and twog and udp_bidirectional + """ + profile_data = {"ssid_name": "ssid_wpa2_2g_eap","security_key": "something","appliedRadios": ["2G"],} + ssid_name = profile_data["ssid_name"] + mode = "BRIDGE" + security = "wpa2" + band = "twog" + eap = "TTLS" + + # Pre-test cleanup to ensure a clean state + get_test_library.pre_cleanup() + + passes, result = get_test_library.enterprise_client_connectivity_test( + ssid=ssid_name, + security=security, + mode=mode, + band=band, + eap=eap, + ttls_passwd="password", + identity="testing", + num_sta=1, + dut_data=setup_configuration, + cleanup=False, + ax_enabled=True, + ) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_bridge_udp_bidirectional", + dut_data=setup_configuration, + dut_mode=dut_mode, + protocol="UDP", upload_rate="10Gbps", download_rate="10Gbps", + num_stations={"2G": 1}, mode="BRIDGE") + assert True + + @allure.testcase(url="https://telecominfraproject.atlassian.net/browse/WIFI-14241", name="WIFI-14241") + @pytest.mark.tcp_upload + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + @allure.title("Single Enterprise AX client TCP Upload wifi capacity") + def test_client_wpa2_bridge_tcp_ul(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in Bridge mode. + This test focuses on stressing the DUT's capacity under the influence of 2.4GHz TCP Upload traffic. + The 2.4GHz station is configured for 20MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and bridge and twog and tcp_upload + """ + profile_data = {"ssid_name": "ssid_wpa2_2g_eap","security_key": "something","appliedRadios": ["2G"],} + ssid_name = profile_data["ssid_name"] + mode = "BRIDGE" + security = "wpa2" + band = "twog" + eap = "TTLS" + # Pre-test cleanup to ensure a clean state + get_test_library.pre_cleanup() + + passes, result = get_test_library.enterprise_client_connectivity_test( + ssid=ssid_name, + security=security, + mode=mode, + band=band, + eap=eap, + ttls_passwd="password", + identity="testing", + num_sta=1, + dut_data=setup_configuration, + cleanup=False, + ax_enabled=True, + ) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_bridge_tcp_ul", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="TCP", upload_rate="10Gbps", download_rate="56Kbps", + num_stations={"2G": 1}, mode="BRIDGE") + assert True + + @allure.testcase(url="https://telecominfraproject.atlassian.net/browse/WIFI-14242", name="WIFI-14242") + @pytest.mark.udp_upload + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + @allure.title("Single Enterprise AX client UDP Upload wifi capacity") + def test_client_wpa2_bridge_udp_ul(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in Bridge mode. + This test focuses on stressing the DUT's capacity under the influence of 2.4GHz UDP Upload traffic. + The 2.4GHz station is configured for 20MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and bridge and twog and udp_upload + """ + profile_data = {"ssid_name": "ssid_wpa2_2g_eap","security_key": "something","appliedRadios": ["2G"],} + ssid_name = profile_data["ssid_name"] + mode = "BRIDGE" + security = "wpa2" + band = "twog" + eap = "TTLS" + # Pre-test cleanup to ensure a clean state + get_test_library.pre_cleanup() + + passes, result = get_test_library.enterprise_client_connectivity_test( + ssid=ssid_name, + security=security, + mode=mode, + band=band, + eap=eap, + ttls_passwd="password", + identity="testing", + num_sta=1, + dut_data=setup_configuration, + cleanup=False, + ax_enabled=True, + ) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_bridge_udp_ul", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="UDP", upload_rate="10Gbps", download_rate="56Kbps", + num_stations={"2G": 1}, mode="BRIDGE") + assert True + +setup_params_general_5G = { + "mode": "BRIDGE", + "ssid_modes": { + "wpa2_enterprise": [ + {"ssid_name": "ssid_wpa2_5g_eap", "appliedRadios": ["5G"], "security_key": "something"} + ] + }, + "rf": { + "5G": { + "band": "5G", + "channel-width": 80, + "channel": 36 + } + }, + "radius": True +} + + +@allure.feature("Performance Test") +@allure.parent_suite("AX Capacity Test") +@allure.suite("5 GHz Band") +@allure.sub_suite("BRIDGE Mode") +@pytest.mark.parametrize( + 'setup_configuration', + [setup_params_general_5G], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_configuration") +@pytest.mark.fiveg +class TestWifiCapacityBRIDGEModeAX5G(object): + @allure.testcase(url="https://telecominfraproject.atlassian.net/browse/WIFI-14236", name="WIFI-14236") + @pytest.mark.tcp_download + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + @allure.title("Single Enterprise AX client TCP Download wifi capacity") + def test_client_wpa2_bridge_tcp_dl(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in Bridge mode. + This test focuses on stressing the DUT's capacity under the influence of 5GHz TCP Download traffic. + The 5GHz station is configured for 80MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and bridge and fiveg and tcp_download + """ + profile_data = {"ssid_name": "ssid_wpa2_5g_eap","security_key": "something","appliedRadios": ["5G"],} + ssid_name = profile_data["ssid_name"] + mode = "BRIDGE" + security = "wpa2" + band = "fiveg" + eap = "TTLS" + # Pre-test cleanup to ensure a clean state + get_test_library.pre_cleanup() + + passes, result = get_test_library.enterprise_client_connectivity_test( + ssid=ssid_name, + security=security, + mode=mode, + band=band, + eap=eap, + ttls_passwd="password", + identity="testing", + num_sta=1, + dut_data=setup_configuration, + cleanup=False, + ax_enabled=True, + ) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_eap_bridge_tcp_dl_eap", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="TCP", upload_rate="56Kbps", download_rate="10Gbps", + num_stations={"5G": 1}, mode="BRIDGE") + assert True + + @allure.testcase(url=" https://telecominfraproject.atlassian.net/browse/WIFI-14237", name="WIFI-14237") + @pytest.mark.udp_download + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + @allure.title("Single Enterprise AX client UDP Download wifi capacity") + def test_client_wpa2_bridge_udp_dl(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in Bridge mode. + This test focuses on stressing the DUT's capacity under the influence of 5GHz UDP Download traffic. + The 5GHz station is configured for 80MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and bridge and fiveg and udp_download + """ + profile_data = {"ssid_name": "ssid_wpa2_5g_eap","security_key": "something","appliedRadios": ["5G"],} + ssid_name = profile_data["ssid_name"] + mode = "BRIDGE" + security = "wpa2" + band = "fiveg" + eap = "TTLS" + # Pre-test cleanup to ensure a clean state + get_test_library.pre_cleanup() + + passes, result = get_test_library.enterprise_client_connectivity_test( + ssid=ssid_name, + security=security, + mode=mode, + band=band, + eap=eap, + ttls_passwd="password", + identity="testing", + num_sta=1, + dut_data=setup_configuration, + cleanup=False, + ax_enabled=True, + ) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_bridge_udp_dl", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="UDP", upload_rate="56Kbps", download_rate="10Gbps", + num_stations={"5G": 1}, mode="BRIDGE") + assert True + + @allure.testcase(url="https://telecominfraproject.atlassian.net/browse/WIFI-6940", name="WIFI-6940") + @pytest.mark.tcp_bidirectional + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + @allure.title("Single Enterprise AX client TCP Bidirectional wifi capacity") + def test_client_wpa2_bridge_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in Bridge mode. + This test focuses on stressing the DUT's capacity under the influence of 5GHz TCP Download and Upload traffic. + The 5GHz station is configured for 80MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and bridge and fiveg and tcp_bidirectional + """ + profile_data = {"ssid_name": "ssid_wpa2_5g_eap","security_key": "something","appliedRadios": ["5G"],} + ssid_name = profile_data["ssid_name"] + mode = "BRIDGE" + security = "wpa2" + band = "fiveg" + eap = "TTLS" + + # Pre-test cleanup to ensure a clean state + get_test_library.pre_cleanup() + + passes, result = get_test_library.enterprise_client_connectivity_test( + ssid=ssid_name, + security=security, + mode=mode, + band=band, + eap=eap, + ttls_passwd="password", + identity="testing", + num_sta=1, + dut_data=setup_configuration, + cleanup=False, + ax_enabled=True, + ) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_bridge_tcp_bidirectional", + dut_data=setup_configuration, + dut_mode=dut_mode, + protocol="TCP", upload_rate="10Gbps", download_rate="10Gbps", + num_stations={"5G": 1}, mode="BRIDGE") + assert True + + @allure.testcase(url="https://telecominfraproject.atlassian.net/browse/WIFI-6940", name="WIFI-6940") + @pytest.mark.udp_bidirectional + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + @allure.title("Single Enterprise AX client UDP Bidirectional wifi capacity") + def test_client_wpa2_bridge_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in Bridge mode. + This test focuses on stressing the DUT's capacity under the influence of 5GHz UDP Download and Upload traffic. + The 5GHz station is configured for 80MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and bridge and fiveg and udp_bidirectional + """ + profile_data = {"ssid_name": "ssid_wpa2_5g_eap","security_key": "something","appliedRadios": ["5G"],} + ssid_name = profile_data["ssid_name"] + mode = "BRIDGE" + security = "wpa2" + band = "fiveg" + eap = "TTLS" + + # Pre-test cleanup to ensure a clean state + get_test_library.pre_cleanup() + + passes, result = get_test_library.enterprise_client_connectivity_test( + ssid=ssid_name, + security=security, + mode=mode, + band=band, + eap=eap, + ttls_passwd="password", + identity="testing", + num_sta=1, + dut_data=setup_configuration, + cleanup=False, + ax_enabled=True, + ) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_bridge_udp_bidirectional", + dut_data=setup_configuration, + dut_mode=dut_mode, + protocol="UDP", upload_rate="10Gbps", download_rate="10Gbps", + num_stations={"5G": 1}, mode="BRIDGE") + assert True + + @allure.testcase(url="https://telecominfraproject.atlassian.net/browse/WIFI-14238", name="WIFI-14238") + @pytest.mark.tcp_upload + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + @allure.title("Single Enterprise AX client TCP Upload wifi capacity") + def test_client_wpa2_bridge_tcp_ul(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in Bridge mode. + This test focuses on stressing the DUT's capacity under the influence of 5GHz TCP Upload traffic. + The 5GHz station is configured for 80MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and bridge and fiveg and tcp_upload + """ + profile_data = {"ssid_name": "ssid_wpa2_5g_eap","security_key": "something","appliedRadios": ["5G"],} + ssid_name = profile_data["ssid_name"] + mode = "BRIDGE" + security = "wpa2" + band = "fiveg" + eap = "TTLS" + # Pre-test cleanup to ensure a clean state + get_test_library.pre_cleanup() + + passes, result = get_test_library.enterprise_client_connectivity_test( + ssid=ssid_name, + security=security, + mode=mode, + band=band, + eap=eap, + ttls_passwd="password", + identity="testing", + num_sta=1, + dut_data=setup_configuration, + cleanup=False, + ax_enabled=True, + ) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_bridge_tcp_ul", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="TCP", upload_rate="10Gbps", download_rate="56Kbps", + num_stations={"5G": 1}, mode="BRIDGE") + assert True + + @allure.testcase(url="https://telecominfraproject.atlassian.net/browse/WIFI-14239", name="WIFI-14239") + @pytest.mark.udp_upload + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + @allure.title("Single Enterprise AX client UDP Upload wifi capacity") + def test_client_wpa2_bridge_udp_ul(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in Bridge mode. + This test focuses on stressing the DUT's capacity under the influence of 5GHz UDP Upload traffic. + The 5GHz station is configured for 80MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and bridge and fiveg and udp_upload + """ + profile_data = {"ssid_name": "ssid_wpa2_5g_eap","security_key": "something","appliedRadios": ["5G"],} + ssid_name = profile_data["ssid_name"] + mode = "BRIDGE" + security = "wpa2" + band = "fiveg" + eap = "TTLS" + # Pre-test cleanup to ensure a clean state + get_test_library.pre_cleanup() + + passes, result = get_test_library.enterprise_client_connectivity_test( + ssid=ssid_name, + security=security, + mode=mode, + band=band, + eap=eap, + ttls_passwd="password", + identity="testing", + num_sta=1, + dut_data=setup_configuration, + cleanup=False, + ax_enabled=True, + ) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_bridge_udp_ul", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="UDP", upload_rate="10Gbps", download_rate="56Kbps", + num_stations={"5G": 1}, mode="BRIDGE") + assert True \ No newline at end of file diff --git a/tests/e2e/basic/performance_tests/AX_capacity/wpa2_personal/test_eap_vlan_mode.py b/tests/e2e/basic/performance_tests/AX_capacity/wpa2_personal/test_eap_vlan_mode.py new file mode 100644 index 000000000..25782bf41 --- /dev/null +++ b/tests/e2e/basic/performance_tests/AX_capacity/wpa2_personal/test_eap_vlan_mode.py @@ -0,0 +1,606 @@ +""" + + Client Connectivity Enterprise TTLS + pytest -m "client_connectivity and vlan and enterprise and ttls" + +""" +import allure +import pytest + +pytestmark = [pytest.mark.vlan, pytest.mark.wifi_capacity_ax_tests, pytest.mark.wpa2_enterprise] + +setup_params_enterprise_2G = { + "mode": "VLAN", + "ssid_modes": { + "wpa2_enterprise": [ + {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["2G"], "vlan": 100}, + ], + }, + + "rf": { + "2G": { + "band": "2G", + "channel-width": 20, + "channel": 6 + } + }, + "radius": True +} + + + +@allure.feature("Performance Test") +@allure.parent_suite("AX Capacity Test") +@allure.suite("2.4 GHz Band") +@allure.sub_suite("vlan Mode") +@pytest.mark.channel_6 +@pytest.mark.parametrize( + 'setup_configuration', + [setup_params_enterprise_2G], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_configuration") +@pytest.mark.twog +class TestWifiCapacityVLANModeAX2G(object): + @pytest.mark.tcp_download + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + @allure.title("Single Enterprise AX client TCP Download wifi capacity") + def test_client_wpa2_eap_vlan_tcp_dl(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in vlan mode. + This test focuses on stressing the DUT's capacity under the influence of 2.4GHz TCP Download traffic. + The 2.4GHz station is configured for 20MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and vlan and twog and tcp_download + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["2G"], "vlan": 100} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "VLAN" + band = "twog" + vlan = [100] + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=num_stations, + vlan_id=vlan, + dut_data=setup_configuration,cleanup=False,ax_enabled=True,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_vlan_tcp_dl_eap", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="TCP", upload_rate="56Kbps", download_rate="10Gbps", + num_stations={"2G": 1}, mode="VLAN", vlan_id=vlan) + assert True + + @pytest.mark.udp_download + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + @allure.title("Single Enterprise AX client UDP Download wifi capacity") + def test_client_wpa2_eap_vlan_udp_dl(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in vlan mode. + This test focuses on stressing the DUT's capacity under the influence of 2.4GHz UDP Download traffic. + The 2.4GHz station is configured for 20MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and vlan and twog and udp_download + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["2G"], "vlan": 100} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "VLAN" + band = "twog" + vlan = [100] + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=num_stations, + vlan_id=vlan, + dut_data=setup_configuration,cleanup=False,ax_enabled=True,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_vlan_tcp_dl_eap", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="UDP", upload_rate="56Kbps", download_rate="10Gbps", + num_stations={"2G": 1}, mode="VLAN", vlan_id=vlan) + assert True + + @pytest.mark.tcp_bidirectional + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + @allure.title("Single Enterprise AX client TCP Bidirectional wifi capacity") + def test_client_wpa2_eap_vlan_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in vlan mode. + This test focuses on stressing the DUT's capacity under the influence of 2.4GHz TCP Download and Upload traffic. + The 2.4GHz station is configured for 20MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and vlan and twog and tcp_bidirectional + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["2G"], "vlan": 100} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "VLAN" + band = "twog" + vlan = [100] + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=num_stations, + vlan_id=vlan, + dut_data=setup_configuration,cleanup=False,ax_enabled=True,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_vlan_tcp_dl_eap", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="TCP", upload_rate="10Gbps", download_rate="10Gbps", + num_stations={"2G": 1}, mode="VLAN", vlan_id=vlan) + assert True + + @pytest.mark.udp_bidirectional + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + @allure.title("Single Enterprise AX client UDP Bidirectional wifi capacity") + def test_client_wpa2_eap_vlan_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in vlan mode. + This test focuses on stressing the DUT's capacity under the influence of 2.4GHz UDP Download and Upload traffic. + The 2.4GHz station is configured for 20MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and vlan and twog and udp_bidirectional + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["2G"], "vlan": 100} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "VLAN" + band = "twog" + vlan = [100] + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=num_stations, + vlan_id=vlan, + dut_data=setup_configuration,cleanup=False,ax_enabled=True,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_vlan_tcp_dl_eap", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="UDP", upload_rate="10Gbps", download_rate="10Gbps", + num_stations={"2G": 1}, mode="VLAN", vlan_id=vlan) + assert True + + @pytest.mark.tcp_upload + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + @allure.title("Single Enterprise AX client TCP Upload wifi capacity") + def test_client_wpa2_eap_vlan_tcp_ul(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in vlan mode. + This test focuses on stressing the DUT's capacity under the influence of 2.4GHz TCP Upload traffic. + The 2.4GHz station is configured for 20MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and vlan and twog and tcp_upload + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["2G"], "vlan": 100} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "VLAN" + band = "twog" + vlan = [100] + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=num_stations, + vlan_id=vlan, + dut_data=setup_configuration,cleanup=False,ax_enabled=True,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_vlan_tcp_dl_eap", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="UDP", upload_rate="10Gbps", download_rate="56Kbps", + num_stations={"2G": 1}, mode="VLAN", vlan_id=vlan) + assert True + + @pytest.mark.udp_upload + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + @allure.title("Single Enterprise AX client UDP Upload wifi capacity") + def test_client_wpa2_eap_vlan_udp_ul(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in vlan mode. + This test focuses on stressing the DUT's capacity under the influence of 2.4GHz UDP Upload traffic. + The 2.4GHz station is configured for 20MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and vlan and twog and udp_upload + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["2G"], "vlan": 100} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "VLAN" + band = "twog" + vlan = [100] + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=num_stations, + vlan_id=vlan, + dut_data=setup_configuration,cleanup=False,ax_enabled=True,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_vlan_tcp_dl_eap", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="UDP", upload_rate="10Gbps", download_rate="56Kbps", + num_stations={"2G": 1}, mode="VLAN", vlan_id=vlan) + assert True + +setup_params_enterprise_5G = { + "mode": "VLAN", + "ssid_modes": { + "wpa2_enterprise": [ + {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["5G"], "vlan": 100}, + ], + }, + + "rf": { + "5G": { + "band": "5G", + "channel-width": 80, + "channel": 36 + } + }, + "radius": True +} + + + +@allure.feature("Performance Test") +@allure.parent_suite("AX Capacity Test") +@allure.suite("5 GHz Band") +@allure.sub_suite("vlan Mode") +@pytest.mark.parametrize( + 'setup_configuration', + [setup_params_enterprise_5G], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_configuration") +@pytest.mark.fiveg +class TestWifiCapacityVLANModeAX5G(object): + @pytest.mark.tcp_download + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + @allure.title("Single Enterprise AX client TCP Download wifi capacity") + def test_client_wpa2_eap_vlan_tcp_dl(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in vlan mode. + This test focuses on stressing the DUT's capacity under the influence of 5GHz TCP Download traffic. + The 5GHz station is configured for 80MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and vlan and fiveg and tcp_download + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["5G"], "vlan": 100} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "VLAN" + band = "fiveg" + vlan = [100] + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=num_stations, + vlan_id=vlan, + dut_data=setup_configuration,cleanup=False,ax_enabled=True,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_vlan_tcp_dl_eap", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="TCP", upload_rate="56Kbps", download_rate="10Gbps", + num_stations={"5G": 1}, mode="VLAN", vlan_id=vlan) + assert True + + @pytest.mark.udp_download + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + @allure.title("Single Enterprise AX client UDP Download wifi capacity") + def test_client_wpa2_eap_vlan_udp_dl(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in vlan mode. + This test focuses on stressing the DUT's capacity under the influence of 5GHz UDP Download traffic. + The 5GHz station is configured for 80MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and vlan and fiveg and udp_download + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["5G"], "vlan": 100} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "VLAN" + band = "fiveg" + vlan = [100] + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=num_stations, + vlan_id=vlan, + dut_data=setup_configuration,cleanup=False,ax_enabled=True,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_vlan_tcp_dl_eap", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="UDP", upload_rate="56Kbps", download_rate="10Gbps", + num_stations={"5G": 1}, mode="VLAN", vlan_id=vlan) + assert True + + @pytest.mark.tcp_bidirectional + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + @allure.title("Single Enterprise AX client TCP Bidirectional wifi capacity") + def test_client_wpa2_eap_vlan_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in vlan mode. + This test focuses on stressing the DUT's capacity under the influence of 5GHz TCP Download and Upload traffic. + The 5GHz station is configured for 80MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and vlan and fiveg and tcp_bidirectional + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["5G"], "vlan": 100} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "VLAN" + band = "fiveg" + vlan = [100] + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=num_stations, + vlan_id=vlan, + dut_data=setup_configuration,cleanup=False,ax_enabled=True,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_vlan_tcp_dl_eap", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="TCP", upload_rate="10Gbps", download_rate="10Gbps", + num_stations={"5G": 1}, mode="VLAN", vlan_id=vlan) + assert True + + @pytest.mark.udp_bidirectional + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + @allure.title("Single Enterprise AX client UDP Bidirectional wifi capacity") + def test_client_wpa2_eap_vlan_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in vlan mode. + This test focuses on stressing the DUT's capacity under the influence of 5GHz UDP Download and Upload traffic. + The 5GHz station is configured for 80MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and vlan and fiveg and udp_bidirectional + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["5G"], "vlan": 100} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "VLAN" + band = "fiveg" + vlan = [100] + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=num_stations, + vlan_id=vlan, + dut_data=setup_configuration,cleanup=False,ax_enabled=True,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_vlan_tcp_dl_eap", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="UDP", upload_rate="10Gbps", download_rate="10Gbps", + num_stations={"5G": 1}, mode="VLAN", vlan_id=vlan) + assert True + + @pytest.mark.tcp_upload + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + @allure.title("Single Enterprise AX client TCP Upload wifi capacity") + def test_client_wpa2_eap_vlan_tcp_ul(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in vlan mode. + This test focuses on stressing the DUT's capacity under the influence of 5GHz TCP Download traffic. + The 5GHz station is configured for 80MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and vlan and fiveg and tcp_upload + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["5G"], "vlan": 100} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "VLAN" + band = "fiveg" + vlan = [100] + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=num_stations, + vlan_id=vlan, + dut_data=setup_configuration,cleanup=False,ax_enabled=True,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_vlan_tcp_dl_eap", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="TCP", upload_rate="10Gbps", download_rate="56Kbps", + num_stations={"5G": 1}, mode="VLAN", vlan_id=vlan) + assert True + + @pytest.mark.udp_upload + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + @allure.title("Single Enterprise AX client UDP Upload wifi capacity") + def test_client_wpa2_eap_vlan_udp_ul(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in vlan mode. + This test focuses on stressing the DUT's capacity under the influence of 5GHz UDP Upload traffic. + The 5GHz station is configured for 80MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and vlan and fiveg and udp_upload + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["5G"], "vlan": 100} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "VLAN" + band = "fiveg" + vlan = [100] + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=num_stations, + vlan_id=vlan, + dut_data=setup_configuration,cleanup=False,ax_enabled=True,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_vlan_tcp_dl_eap", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="UDP", upload_rate="10Gbps", download_rate="56Kbps", + num_stations={"5G": 1}, mode="VLAN", vlan_id=vlan) + assert True + \ No newline at end of file diff --git a/tests/e2e/basic/performance_tests/AX_capacity/wpa2_personal/test_nat_eap.py b/tests/e2e/basic/performance_tests/AX_capacity/wpa2_personal/test_nat_eap.py new file mode 100644 index 000000000..d0aa2ae9e --- /dev/null +++ b/tests/e2e/basic/performance_tests/AX_capacity/wpa2_personal/test_nat_eap.py @@ -0,0 +1,589 @@ +""" + + Client Connectivity Enterprise TTLS + pytest -m "client_connectivity and nat and enterprise and ttls" + +""" +import allure +import pytest + +pytestmark = [pytest.mark.nat, pytest.mark.wifi_capacity_ax_tests, pytest.mark.wpa2_enterprise] + +setup_params_enterprise_2G = { + "mode": "NAT", + "ssid_modes": { + "wpa2_enterprise": [ + {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["2G"]}, + ], + }, + "rf": { + "2G": { + "band": "2G", + "channel-width": 20, + "channel": 6 + } + }, + "radius": True +} + + +@allure.feature("Performance Test") +@allure.parent_suite("AX Capacity Test") +@allure.suite("2.4 GHz Band") +@allure.sub_suite("NAT Mode") +@pytest.mark.channel_6 +@pytest.mark.parametrize( + 'setup_configuration', + [setup_params_enterprise_2G], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_configuration") +@pytest.mark.twog +class TestWifiCapacityNATModeAX2G(object): + """ SuiteA Enterprise Test Cases + pytest -m "client_connectivity_tests and nat and enterprise and ttls and suiteA" + """ + @pytest.mark.tcp_download + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + @allure.title("Single Enterprise AX client TCP Download wifi capacity") + def test_client_wpa2_eap_nat_tcp_dl(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in NAT mode. + This test focuses on stressing the DUT's capacity under the influence of 2.4GHz TCP Download traffic. + The 2.4GHz station is configured for 20MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and NAT and twog and tcp_download + """ + + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["2G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "NAT-WAN" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=num_stations, + dut_data=setup_configuration,cleanup=False,ax_enabled=True,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_nat_tcp_dl_eap", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="TCP", upload_rate="56Kbps", download_rate="10Gbps", + num_stations={"2G": 1}, mode="NAT-WAN") + assert True + + @pytest.mark.udp_download + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + @pytest.mark.decf + @allure.title("Single Enterprise AX client UDP Download wifi capacity") + def test_client_wpa2_eap_nat_udp_dl(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in NAT mode. + This test focuses on stressing the DUT's capacity under the influence of 2.4GHz UDP Download traffic. + The 2.4GHz station is configured for 20MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and NAT and twog and udp_download + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["2G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "NAT-WAN" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=num_stations, + dut_data=setup_configuration,cleanup=False,ax_enabled=True,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_nat_udp_dl_eap", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="UDP", upload_rate="56Kbps", download_rate="10Gbps", + num_stations={"2G": 1}, mode="NAT-WAN") + assert True + + @pytest.mark.tcp_bidirectional + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + @allure.title("Single Enterprise AX client TCP Bidirectional wifi capacity") + def test_client_wpa2_eap_nat_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in NAT mode. + This test focuses on stressing the DUT's capacity under the influence of 2.4GHz TCP Download and Upload traffic. + The 2.4GHz station is configured for 20MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and NAT and twog and tcp_bidirectional + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["2G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "NAT-WAN" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=num_stations, + dut_data=setup_configuration,cleanup=False,ax_enabled=True,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_eap_nat_tcp_bidirectional", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="TCP", upload_rate="10Gbps", download_rate="10Gbps", + num_stations={"2G": 1}, mode="NAT-WAN") + assert True + + @pytest.mark.udp_bidirectional + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + @allure.title("Single Enterprise AX client UDP Bidirectional wifi capacity") + def test_client_wpa2_eap_nat_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in NAT mode. + This test focuses on stressing the DUT's capacity under the influence of 2.4GHz UDP Download and Upload traffic. + The 2.4GHz station is configured for 20MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and NAT and twog and udp_bidirectional + """ + + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["2G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "NAT-WAN" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=num_stations, + dut_data=setup_configuration,cleanup=False,ax_enabled=True,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_eap_nat_udp_bidirectional", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="UDP", upload_rate="10Gbps", download_rate="10Gbps", + num_stations={"2G": 1}, mode="NAT-WAN") + assert True + + @pytest.mark.udp_upload + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + @pytest.mark.bcdfiw + @allure.title("Single Enterprise AX client UDP Upload wifi capacity") + def test_client_wpa2_eap_nat_udp_ul(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in NAT mode. + This test focuses on stressing the DUT's capacity under the influence of 2.4GHz UDP Upload traffic. + The 2.4GHz station is configured for 20MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and NAT and twog and udp_upload + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["2G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "NAT-WAN" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=num_stations, + dut_data=setup_configuration,cleanup=False,ax_enabled=True,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_eap_nat_udp_ul", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="UDP", upload_rate="10Gbps", download_rate="56Kbps", + num_stations={"2G": 1}, mode="NAT-WAN") + assert True + + @pytest.mark.tcp_upload + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + @allure.title("Single Enterprise AX client TCP Upload wifi capacity") + def test_client_wpa2_eap_nat_tcp_ul(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in NAT mode. + This test focuses on stressing the DUT's capacity under the influence of 2.4GHz TCP Upload traffic. + The 2.4GHz station is configured for 20MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and NAT and twog and tcp_upload + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["2G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "NAT-WAN" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=num_stations, + dut_data=setup_configuration,cleanup=False,ax_enabled=True,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_eap_nat_tcp_ul", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="TCP", upload_rate="10Gbps", download_rate="56Kbps", + num_stations={"2G": 1}, mode="NAT-WAN") + assert True + +setup_params_enterprise_5G = { + "mode": "NAT", + "ssid_modes": { + "wpa2_enterprise": [ + {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["5G"]}, + ], + }, + "rf": { + "5G": { + "band": "5G", + "channel-width": 80, + "channel": 36 + } + }, + "radius": True +} + + +@allure.feature("Performance Test") +@allure.parent_suite("AX Capacity Test") +@allure.suite("5 GHz Band") +@allure.sub_suite("NAT Mode") +@pytest.mark.parametrize( + 'setup_configuration', + [setup_params_enterprise_5G], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_configuration") +@pytest.mark.fiveg +class TestWifiCapacityNATModeAX5G(object): + """ SuiteA Enterprise Test Cases + pytest -m "client_connectivity_tests and nat and enterprise and ttls and suiteA" + """ + @pytest.mark.tcp_download + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + @allure.title("Single Enterprise AX client TCP Download wifi capacity") + def test_client_wpa2_eap_nat_tcp_dl(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in NAT mode. + This test focuses on stressing the DUT's capacity under the influence of 5GHz TCP Download traffic. + The 5GHz station is configured for 80MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and NAT and fiveg and tcp_download + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["5G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "NAT-WAN" + band = "fiveg" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=num_stations, + dut_data=setup_configuration,cleanup=False,ax_enabled=True,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_eap_nat_tcp_dl", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="TCP", upload_rate="56Kbps", download_rate="10Gbps", + num_stations={"5G": 1}, mode="NAT-WAN") + assert True + + @pytest.mark.udp_download + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + @allure.title("Single Enterprise AX client UDP Download wifi capacity") + def test_client_wpa2_eap_nat_udp_dl(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in NAT mode. + This test focuses on stressing the DUT's capacity under the influence of 5GHz UDP Download traffic. + The 5GHz station is configured for 80MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and NAT and fiveg and udp_download + """ + + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["5G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "NAT-WAN" + band = "fiveg" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=num_stations, + dut_data=setup_configuration,cleanup=False,ax_enabled=True,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_eap_nat_udp_dl", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="UDP", upload_rate="56Kbps", download_rate="10Gbps", + num_stations={"5G": 1}, mode="NAT-WAN") + assert True + + @pytest.mark.tcp_bidirectional + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + @allure.title("Single Enterprise AX client TCP Bidirectional wifi capacity") + def test_client_wpa2_eap_nat_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in NAT mode. + This test focuses on stressing the DUT's capacity under the influence of 5GHz TCP Download and Upload traffic. + The 5GHz station is configured for 80MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and NAT and fiveg and tcp_bidirectional + """ + + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["5G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "NAT-WAN" + band = "fiveg" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=num_stations, + dut_data=setup_configuration,cleanup=False,ax_enabled=True,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_eap_nat_tcp_bidirectional", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="TCP", upload_rate="10Gbps", download_rate="10Gbps", + num_stations={"5G": 1}, mode="NAT-WAN") + assert True + + @pytest.mark.udp_bidirectional + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + @allure.title("Single Enterprise AX client UDP Bidirectional wifi capacity") + def test_client_wpa2_eap_nat_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in NAT mode. + This test focuses on stressing the DUT's capacity under the influence of 5GHz UDP Download and Upload traffic. + The 5GHz station is configured for 80MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and NAT and fiveg and udp_bidirectional + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["5G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "NAT-WAN" + band = "fiveg" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=num_stations, + dut_data=setup_configuration,cleanup=False,ax_enabled=True,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_eap_nat_udp_bidirectional", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="UDP", upload_rate="10Gbps", download_rate="10Gbps", + num_stations={"5G": 1}, mode="NAT-WAN") + assert True + + @pytest.mark.udp_upload + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + @allure.title("Single Enterprise AX client UDP Upload wifi capacity") + def test_client_wpa2_eap_nat_udp_ul(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in NAT mode. + This test focuses on stressing the DUT's capacity under the influence of 5GHz UDP Upload traffic. + The 5GHz station is configured for 80MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and NAT and fiveg and udp_upload + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["5G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "NAT-WAN" + band = "fiveg" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=num_stations, + dut_data=setup_configuration,cleanup=False,ax_enabled=True,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_eap_nat_udp_ul", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="UDP", upload_rate="10Gbps", download_rate="56Kbps", + num_stations={"5G": 1}, mode="NAT-WAN") + assert True + @pytest.mark.tcp_upload + @pytest.mark.performance + @pytest.mark.ow_sanity_lf + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + @allure.title("Single Enterprise AX client TCP Upload wifi capacity") + def test_client_wpa2_eap_nat_tcp_ul(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info): + """ + Description: + The test case examines the maximum performance of a DUT supporting 802.11ax clients in NAT mode. + This test focuses on stressing the DUT's capacity under the influence of 5GHz TCP Download traffic. + The 5GHz station is configured for 80MHz bandwidth, two spatial streams, and WPA2 Enterprise security using TTLS authentication. + + Markers: + wifi_capacity_ax_tests and wpa2_enterprise and NAT and fiveg and tcp_upload + """ + + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["5G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "NAT-WAN" + band = "fiveg" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=num_stations, + dut_data=setup_configuration,cleanup=False,ax_enabled=True,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + dut_mode = get_lab_info.CONFIGURATION[selected_testbed]["device_under_tests"][0]["mode"] + get_test_library.ax_eap_capacity_test(instance_name="test_client_wpa2_eap_nat_tcp_ul", + dut_data=setup_configuration, dut_mode=dut_mode, + protocol="TCP", upload_rate="10Gbps", download_rate="56Kbps", + num_stations={"5G": 1}, mode="NAT-WAN") + assert True \ No newline at end of file diff --git a/tests/e2e/basic/performance_tests/client_scale_test/wpa2_personal/test_bridge_eap.py b/tests/e2e/basic/performance_tests/client_scale_test/wpa2_personal/test_bridge_eap.py new file mode 100644 index 000000000..433a8d3e3 --- /dev/null +++ b/tests/e2e/basic/performance_tests/client_scale_test/wpa2_personal/test_bridge_eap.py @@ -0,0 +1,636 @@ +""" + Performance Test: Client Scale Test : BRIDGE Mode + pytest -m "wifi_capacity_client_scale_tests and wpa2_enterprise and bridge" +""" +import pytest +import allure + +pytestmark = [pytest.mark.performance, pytest.mark.bridge, pytest.mark.client_scale_tests] +setup_params_general_2G = { + "mode": "BRIDGE", + "ssid_modes": { + "wpa2_enterprise": [ + {"ssid_name": "ssid_wpa2_2g_eap", "appliedRadios": ["2G"], "security_key": "something"} + ] + }, + "rf": {}, + "radius": True +} + +@allure.feature("Performance Test") +@allure.parent_suite("Client Scale Test") +@allure.suite("2.4 GHz Band") +@allure.sub_suite("BRIDGE Mode") +@pytest.mark.parametrize( + 'setup_configuration', + [setup_params_general_2G], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_configuration") +@pytest.mark.twog +@pytest.mark.wpa2_enterprise +class TestWifiCapacityEnterpriseBRIDGEMode2G(object): + @pytest.mark.wpa2_enterprise + @pytest.mark.tcp_download + @pytest.mark.twog + @allure.title("Test for TCP Download 2.4 GHz") + def test_client_wpa2_bridge_tcp_dl(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA2 Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA2 Enterprise security. + It focuses on the 2.4GHz band with TCP download traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, bridge, wap2_enterprise, twog,tcp_download + """ + + profile_data = {"ssid_name": "ssid_wpa2_2g_eap","security_key": "something","appliedRadios": ["2G"],} + ssid_name = profile_data["ssid_name"] + mode = "BRIDGE" + security = "wpa2" + band = "twog" + eap = "TTLS" + # Pre-test cleanup to ensure a clean state + get_test_library.pre_cleanup() + + passes, result = get_test_library.enterprise_client_connectivity_test( + ssid=ssid_name, + security=security, + mode=mode, + band=band, + eap=eap, + ttls_passwd="password", + identity="testing", + num_sta=max_stations, + dut_data=setup_configuration, + cleanup=False, + ) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_tcp_dl_eap", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="0Gbps", protocol="TCP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"2G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa2_enterprise + @pytest.mark.udp_download + @pytest.mark.twog + @allure.title("Test for UDP Download 2.4 GHz") + def test_client_wpa2_bridge_udp_dl(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA2 Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA2 Enterprise security. + It focuses on the 2.4GHz band with UDP download traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**:performance,client_scale_tests, bridge, wpa2_enterprise, twog,udp_download, + """ + + profile_data = {"ssid_name": "ssid_wpa2_2g_eap","security_key": "something","appliedRadios": ["2G"],} + ssid_name = profile_data["ssid_name"] + mode = "BRIDGE" + security = "wpa2" + band = "twog" + eap = "TTLS" + # Pre-test cleanup to ensure a clean state + get_test_library.pre_cleanup() + + passes, result = get_test_library.enterprise_client_connectivity_test( + ssid=ssid_name, + security=security, + mode=mode, + band=band, + eap=eap, + ttls_passwd="password", + identity="testing", + num_sta=max_stations, + dut_data=setup_configuration, + cleanup=False, + ) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_udp_dl_eap", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="0Gbps", protocol="UDP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"2G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa2_enterprise + @pytest.mark.tcp_bidirectional + @pytest.mark.twog + @allure.title("Test for TCP Bidirectional 2.4 GHz") + def test_client_wpa2_bridge_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA2 Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA2 Enterprise security. + It focuses on the 2.4GHz band with TCP download and upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**:performance, client_scale_tests, bridge, wpa2_enterprise, twog, tcp_bidirectional + """ + + profile_data = {"ssid_name": "ssid_wpa2_2g_eap","security_key": "something","appliedRadios": ["2G"],} + ssid_name = profile_data["ssid_name"] + mode = "BRIDGE" + security = "wpa2" + band = "twog" + eap = "TTLS" + # Pre-test cleanup to ensure a clean state + get_test_library.pre_cleanup() + + passes, result = get_test_library.enterprise_client_connectivity_test( + ssid=ssid_name, + security=security, + mode=mode, + band=band, + eap=eap, + ttls_passwd="password", + identity="testing", + num_sta=max_stations, + dut_data=setup_configuration, + cleanup=False, + ) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_tcp_bidirectional_eap", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="TCP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"2G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa2_enterprise + @pytest.mark.udp_bidirectional + @pytest.mark.twog + @allure.testcase(url="https://telecominfraproject.atlassian.net/browse/WIFI-14329", name="WIFI-14329") + @allure.title("Test for UDP Bidirectional 2.4 GHz") + def test_client_wpa2_bridge_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA2 Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA2 Enterprise security. + It focuses on the 2.4GHz band with UDP download and upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**:performance, client_scale_tests, bridge, wpa2_enterprise, twog, udp_bidirectional + """ + + profile_data = {"ssid_name": "ssid_wpa2_2g_eap","security_key": "something","appliedRadios": ["2G"],} + ssid_name = profile_data["ssid_name"] + mode = "BRIDGE" + security = "wpa2" + band = "twog" + eap = "TTLS" + # Pre-test cleanup to ensure a clean state + get_test_library.pre_cleanup() + + passes, result = get_test_library.enterprise_client_connectivity_test( + ssid=ssid_name, + security=security, + mode=mode, + band=band, + eap=eap, + ttls_passwd="password", + identity="testing", + num_sta=max_stations, + dut_data=setup_configuration, + cleanup=False, + ) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_udp_bidirectional_eap", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="UDP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"2G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa2_enterprise + @pytest.mark.tcp_upload + @pytest.mark.twog + @allure.title("Test for TCP Upload 2.4 GHz") + def test_client_wpa2_bridge_tcp_ul(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA2 Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA2 Enterprise security. + It focuses on the 2.4GHz band with TCP upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**:performance, client_scale_tests, bridge, wpa2_enterprise, twog, tcp_upload + """ + + # Pre-test cleanup to ensure a clean state + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_2g_eap","security_key": "something","appliedRadios": ["2G"],} + ssid_name = profile_data["ssid_name"] + mode = "BRIDGE" + security = "wpa2" + band = "twog" + eap = "TTLS" + + passes, result = get_test_library.enterprise_client_connectivity_test( + ssid=ssid_name, + security=security, + mode=mode, + band=band, + eap=eap, + ttls_passwd="password", + identity="testing", + num_sta=max_stations, + dut_data=setup_configuration, + cleanup=False, + ) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_tcp_ul_eap", mode=mode, + download_rate="100Kbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="TCP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"2G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa2_enterprise + @pytest.mark.udp_upload + @pytest.mark.twog + @allure.title("Test for UDP Upload 2.4 GHz") + def test_client_wpa2_bridge_udp_ul(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA2 Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA2 Enterprise security. + It focuses on the 2.4GHz band with UDP upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**:performance, client_scale_tests, bridge, wpa2_enterprise, twog, udp_upload + """ + + # Pre-test cleanup to ensure a clean state + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_2g_eap","security_key": "something","appliedRadios": ["2G"],} + ssid_name = profile_data["ssid_name"] + mode = "BRIDGE" + security = "wpa2" + band = "twog" + eap = "TTLS" + + passes, result = get_test_library.enterprise_client_connectivity_test( + ssid=ssid_name, + security=security, + mode=mode, + band=band, + eap=eap, + ttls_passwd="password", + identity="testing", + num_sta=max_stations, + dut_data=setup_configuration, + cleanup=False, + ) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_udp_ul_eap", mode=mode, + download_rate="100Kbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="UDP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"2G": max_stations},add_stations=False) + assert True + + + +setup_params_general_5G = { + "mode": "BRIDGE", + "ssid_modes": { + "wpa2_enterprise": [ + {"ssid_name": "ssid_wpa2_5g_eap", "appliedRadios": ["5G"], "security_key": "something"} + ] + }, + "rf": {}, + "radius": True +} + + +@allure.feature("Performance Test") +@allure.parent_suite("Client Scale Test") +@allure.suite("5 GHz Band") +@allure.sub_suite("BRIDGE Mode") +@pytest.mark.parametrize( + 'setup_configuration', + [setup_params_general_5G], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_configuration") +@pytest.mark.fiveg +class TestWifiCapacityEnterpriseBRIDGEMode5G(object): + @pytest.mark.wpa2_enterprise + @pytest.mark.tcp_download + @pytest.mark.fiveg + @allure.title("Test for TCP Download 5 GHz") + def test_client_wpa2_bridge_tcp_dl(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA2 Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA2 Enterprise security. + It focuses on the 5GHz band with TCP download traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**:performance, client_scale_tests, bridge, wpa2_enterprise, fiveg, tcp_download + """ + + profile_data = {"ssid_name": "ssid_wpa2_5g_eap","security_key": "something","appliedRadios": ["5G"],} + ssid_name = profile_data["ssid_name"] + mode = "BRIDGE" + security = "wpa2" + band = "fiveg" + eap = "TTLS" + # Pre-test cleanup to ensure a clean state + get_test_library.pre_cleanup() + + passes, result = get_test_library.enterprise_client_connectivity_test( + ssid=ssid_name, + security=security, + mode=mode, + band=band, + eap=eap, + ttls_passwd="password", + identity="testing", + num_sta=max_stations, + dut_data=setup_configuration, + cleanup=False, + ) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_tcp_dl_eap", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="0Gbps", protocol="TCP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"5G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa2_enterprise + @pytest.mark.udp_download + @pytest.mark.fiveg + @allure.title("Test for UDP Download 5 GHz") + def test_client_wpa2_bridge_udp_dl(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA2 Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA2 Enterprise security. + It focuses on the 5GHz band with UDP download traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**:performance, client_scale_tests, bridge, wpa2_enterprise, fiveg, udp_download + """ + + profile_data = {"ssid_name": "ssid_wpa2_5g_eap","security_key": "something","appliedRadios": ["5G"],} + ssid_name = profile_data["ssid_name"] + mode = "BRIDGE" + security = "wpa2" + band = "fiveg" + eap = "TTLS" + # Pre-test cleanup to ensure a clean state + get_test_library.pre_cleanup() + + passes, result = get_test_library.enterprise_client_connectivity_test( + ssid=ssid_name, + security=security, + mode=mode, + band=band, + eap=eap, + ttls_passwd="password", + identity="testing", + num_sta=max_stations, + dut_data=setup_configuration, + cleanup=False, + ) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_udp_dl_eap", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="0Gbps", protocol="UDP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"5G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa2_enterprise + @pytest.mark.tcp_bidirectional + @pytest.mark.fiveg + @allure.testcase(url="https://telecominfraproject.atlassian.net/browse/WIFI-14330", name="WIFI-14330") + @allure.title("Test for TCP Bidirectional 5 GHz") + def test_client_wpa2_bridge_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA2 Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA2 Enterprise security. + It focuses on the 5GHz band with TCP download and upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**:performance, client_scale_tests, bridge, wpa2_enterprise, fiveg, tcp_bidirectional + """ + + profile_data = {"ssid_name": "ssid_wpa2_5g_eap","security_key": "something","appliedRadios": ["5G"],} + ssid_name = profile_data["ssid_name"] + mode = "BRIDGE" + security = "wpa2" + band = "fiveg" + eap = "TTLS" + # Pre-test cleanup to ensure a clean state + get_test_library.pre_cleanup() + + passes, result = get_test_library.enterprise_client_connectivity_test( + ssid=ssid_name, + security=security, + mode=mode, + band=band, + eap=eap, + ttls_passwd="password", + identity="testing", + num_sta=max_stations, + dut_data=setup_configuration, + cleanup=False, + ) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_tcp_bidirectional;_eap", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="TCP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"5G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa2_enterprise + @pytest.mark.udp_bidirectional + @pytest.mark.fiveg + @allure.title("Test for UDP Bidirectional 5 GHz") + def test_client_wpa2_bridge_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA2 Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA2 Enterprise security. + It focuses on the 5GHz band with UDP download and upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**:performance, client_scale_tests, bridge, wpa2_enterprise, fiveg, udp_bidirectional + """ + + profile_data = {"ssid_name": "ssid_wpa2_5g_eap","security_key": "something","appliedRadios": ["5G"],} + ssid_name = profile_data["ssid_name"] + mode = "BRIDGE" + security = "wpa2" + band = "fiveg" + eap = "TTLS" + # Pre-test cleanup to ensure a clean state + get_test_library.pre_cleanup() + + passes, result = get_test_library.enterprise_client_connectivity_test( + ssid=ssid_name, + security=security, + mode=mode, + band=band, + eap=eap, + ttls_passwd="password", + identity="testing", + num_sta=max_stations, + dut_data=setup_configuration, + cleanup=False, + ) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_udp_bidirectional_eap", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="UDP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"5G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa2_enterprise + @pytest.mark.tcp_upload + @pytest.mark.fiveg + @allure.title("Test for TCP Upload 5 GHz") + def test_client_wpa2_bridge_tcp_ul(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA2 Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA2 Enterprise security. + It focuses on the 5GHz band with TCP upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**:performance, client_scale_tests, bridge, wpa2_enterprise, fiveg, tcp_upload + """ + + # Pre-test cleanup to ensure a clean state + profile_data = {"ssid_name": "ssid_wpa2_5g_eap","security_key": "something","appliedRadios": ["5G"],} + ssid_name = profile_data["ssid_name"] + mode = "BRIDGE" + security = "wpa2" + band = "fiveg" + eap = "TTLS" + get_test_library.pre_cleanup() + passes, result = get_test_library.enterprise_client_connectivity_test( + ssid=ssid_name, + security=security, + mode=mode, + band=band, + eap=eap, + ttls_passwd="password", + identity="testing", + num_sta=max_stations, + dut_data=setup_configuration, + cleanup=False, + ) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_tcp_ul_eap", mode=mode, + download_rate="100Kbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="TCP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"5G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa2_enterprise + @pytest.mark.udp_upload + @pytest.mark.fiveg + @allure.title("Test for UDP Upload 2.4 GHz") + def test_client_wpa2_bridge_udp_ul(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA2 Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA2 Enterprise security. + It focuses on the 5GHz band with UDP upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**:performance, client_scale_tests, bridge, wpa2_enterprise, fiveg, tcp_download + """ + + # Pre-test cleanup to ensure a clean state + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_5g_eap","security_key": "something","appliedRadios": ["5G"],} + ssid_name = profile_data["ssid_name"] + mode = "BRIDGE" + security = "wpa2" + band = "fiveg" + eap = "TTLS" + + passes, result = get_test_library.enterprise_client_connectivity_test( + ssid=ssid_name, + security=security, + mode=mode, + band=band, + eap=eap, + ttls_passwd="password", + identity="testing", + num_sta=max_stations, + dut_data=setup_configuration, + cleanup=False, + ) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_udp_ul_eap", mode=mode, + download_rate="100Kbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="UDP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"5G": max_stations},add_stations=False) + assert True \ No newline at end of file diff --git a/tests/e2e/basic/performance_tests/client_scale_test/wpa2_personal/test_nat_eap.py b/tests/e2e/basic/performance_tests/client_scale_test/wpa2_personal/test_nat_eap.py new file mode 100644 index 000000000..a35a9f301 --- /dev/null +++ b/tests/e2e/basic/performance_tests/client_scale_test/wpa2_personal/test_nat_eap.py @@ -0,0 +1,544 @@ +""" + + Client Scale Test TTLS + pytest -m "client_scale_test and nat and enterprise and ttls" + +""" +import allure +import pytest + +pytestmark = [pytest.mark.performance, pytest.mark.nat, pytest.mark.client_scale_tests] + + +setup_params_general_2G = { + "mode": "NAT", + "ssid_modes": { + "wpa2_enterprise":[ + {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["2G"]} + ], + }, + + "rf": {}, + "radius": True +} + + +@allure.feature("Performance Test") +@allure.parent_suite("Client Scale Test") +@allure.suite("2.4 GHz Band") +@allure.sub_suite("NAT Mode") +@pytest.mark.parametrize( + 'setup_configuration', + [setup_params_general_2G], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_configuration") +@pytest.mark.twog +@pytest.mark.wpa2_enterprise +class TestWifiCapacityEnterpriseNATMode2G(object): + @pytest.mark.wpa2_enterprise + @pytest.mark.tcp_download + @pytest.mark.twog + @allure.title("Test for TCP Download 2.4 GHz") + def test_client_wpa2_eap_nat_tcp_dl(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA2 Enterprise Security + + This test evaluates the scalability and performance of a network in NAT mode using WPA2 Enterprise security. + It focuses on the 2.4GHz band with TCP download traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, nat, wpa2_enterprise, twog, tcp_download + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["2G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "NAT-WAN" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=num_stations, + dut_data=setup_configuration,cleanup=False,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_tcp_dl_eap", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="0Gbps", protocol="TCP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"2G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa2_enterprise + @pytest.mark.udp_download + @pytest.mark.twog + @allure.title("Test for UDP Download 2.4 GHz") + def test_client_wpa2_eap_nat_udp_dl(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA2 Enterprise Security + + This test evaluates the scalability and performance of a network in NAT mode using WPA2 Enterprise security. + It focuses on the 2.4GHz band with UDP download traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, nat, wpa2_enterprise, twog, udp_download + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["2G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "NAT-WAN" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration,cleanup=False,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_udp_dl_eap", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="0Gbps", protocol="UDP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"2G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa2_enterprise + @pytest.mark.tcp_bidirectional + @pytest.mark.twog + @allure.title("Test for TCP Bidirectional 2.4 GHz") + def test_client_wpa2_eap_nat_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA2 Enterprise Security + + This test evaluates the scalability and performance of a network in NAT mode using WPA2 Enterprise security. + It focuses on the 2.4GHz band with TCP download and upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, nat, wpa2_enterprise, twog, tcp_bidirectional + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["2G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "NAT-WAN" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration,cleanup=False,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_tcp_bidirectional", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="TCP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"2G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa2_enterprise + @pytest.mark.udp_bidirectional + @pytest.mark.twog + @allure.title("Test for UDP Bidirectional 2.4 GHz") + def test_client_wpa2_eap_nat_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA2 Enterprise Security + + This test evaluates the scalability and performance of a network in NAT mode using WPA2 Enterprise security. + It focuses on the 2.4GHz band with UDP download and upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, nat, wpa2_enterprise, twog, udp_bidirectional + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["2G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "NAT-WAN" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration,cleanup=False,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_udp_bidirectional", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="UDP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"2G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa2_enterprise + @pytest.mark.tcp_upload + @pytest.mark.twog + @allure.title("Test for TCP Upload 2.4 GHz") + def test_client_wpa2_eap_nat_tcp_upload(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA2 Enterprise Security + + This test evaluates the scalability and performance of a network in NAT mode using WPA2 Enterprise security. + It focuses on the 2.4GHz band with TCP upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, nat, wpa2_enterprise, twog, tcp_upload + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["2G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "NAT-WAN" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration,cleanup=False,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_tcp_upload", mode=mode, + download_rate="100Kbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="TCP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"2G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa2_enterprise + @pytest.mark.udp_upload + @pytest.mark.twog + @allure.title("Test for UDP Upload 2.4 GHz") + def test_client_wpa2_eap_nat_udp_upload(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA2 Enterprise Security + + This test evaluates the scalability and performance of a network in NAT mode using WPA2 Enterprise security. + It focuses on the 2.4GHz band with UDP upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, nat, wpa2_enterprise, twog, udp_upload + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["2G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "NAT-WAN" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration,cleanup=False,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_udp_upload", mode=mode, + download_rate="100Kbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="UDP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"2G": max_stations},add_stations=False) + assert True + +setup_params_general_5G = { + "mode": "NAT", + "ssid_modes": { + "wpa2_enterprise": [ + {"ssid_name": "ssid_wpa2_5g_eap", "appliedRadios": ["5G"], "security_key": "something"} + ] + }, + "rf": {}, + "radius": True +} + +@allure.feature("Performance Test") +@allure.parent_suite("Client Scale Test") +@allure.suite("5 GHz Band") +@allure.sub_suite("NAT Mode") +@pytest.mark.parametrize( + 'setup_configuration', + [setup_params_general_5G], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_configuration") +@pytest.mark.fiveg +@pytest.mark.wpa2_enterprise +class TestWifiCapacityEnterpriseNATMode5G(object): + @pytest.mark.wpa2_enterprise + @pytest.mark.tcp_download + @pytest.mark.twog + @allure.title("Test for TCP Download 5 GHz") + def test_client_wpa2_eap_nat_tcp_dl(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA2 Enterprise Security + + This test evaluates the scalability and performance of a network in NAT mode using WPA2 Enterprise security. + It focuses on the 5GHz band with TCP download traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, nat, wpa2_enterprise, twog, tcp_download + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["5G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "NAT-WAN" + band = "fiveg" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=num_stations, + dut_data=setup_configuration,cleanup=False,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_tcp_dl_eap", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="0Gbps", protocol="TCP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"5G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa2_enterprise + @pytest.mark.udp_download + @pytest.mark.twog + @allure.title("Test for UDP Download 5 GHz") + def test_client_wpa2_eap_nat_udp_dl(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA2 Enterprise Security + + This test evaluates the scalability and performance of a network in NAT mode using WPA2 Enterprise security. + It focuses on the 5GHz band with UDP download traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, nat, wpa2_enterprise, twog, udp_download + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["5G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "NAT-WAN" + band = "fiveg" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration,cleanup=False,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_udp_dl_eap", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="0Gbps", protocol="UDP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"5G": max_stations},add_stations=False) + assert True + + + @pytest.mark.wpa2_enterprise + @pytest.mark.tcp_bidirectional + @pytest.mark.twog + @allure.title("Test for TCP Bidirectional 5 GHz") + def test_client_wpa2_eap_nat_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA2 Enterprise Security + + This test evaluates the scalability and performance of a network in NAT mode using WPA2 Enterprise security. + It focuses on the 2.4GHz band with TCP download and upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, nat, wpa2_enterprise, twog, tcp_bidirectional + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["5G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "NAT-WAN" + band = "fiveg" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration,cleanup=False,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_tcp_bidirectional", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="TCP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"5G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa2_enterprise + @pytest.mark.udp_bidirectional + @pytest.mark.twog + @allure.title("Test for UDP Bidirectional 5 GHz") + def test_client_wpa2_eap_nat_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA2 Enterprise Security + + This test evaluates the scalability and performance of a network in NAT mode using WPA2 Enterprise security. + It focuses on the 2.4GHz band with UDP download and upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, nat, wpa2_enterprise, twog, udp_bidirectional + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["5G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "NAT-WAN" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration,cleanup=False,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_udp_bidirectional", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="UDP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"5G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa2_enterprise + @pytest.mark.tcp_upload + @pytest.mark.twog + @allure.title("Test for TCP Upload 5 GHz") + def test_client_wpa2_eap_nat_tcp_upload(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA2 Enterprise Security + + This test evaluates the scalability and performance of a network in NAT mode using WPA2 Enterprise security. + It focuses on the 2.4GHz band with TCP upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, nat, wpa2_enterprise, twog, tcp_upload + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["5G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "NAT-WAN" + band = "fiveg" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration,cleanup=False,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_tcp_upload", mode=mode, + download_rate="100Kbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="TCP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"5G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa2_enterprise + @pytest.mark.udp_upload + @pytest.mark.twog + @allure.title("Test for UDP Upload 5 GHz") + def test_client_wpa2_eap_nat_udp_upload(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, num_stations, setup_configuration, + get_lab_info, selected_testbed, check_connectivity,radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA2 Enterprise Security + + This test evaluates the scalability and performance of a network in NAT mode using WPA2 Enterprise security. + It focuses on the 2.4GHz band with UDP upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, nat, wpa2_enterprise, twog, udp_upload + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["5G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa2" + mode = "NAT-WAN" + band = "fiveg" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration,cleanup=False,) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_udp_upload", mode=mode, + download_rate="100Kbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="UDP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"5G": max_stations},add_stations=False) + assert True \ No newline at end of file diff --git a/tests/e2e/basic/performance_tests/client_scale_test/wpa3_personal/test_bridge_eap.py b/tests/e2e/basic/performance_tests/client_scale_test/wpa3_personal/test_bridge_eap.py new file mode 100644 index 000000000..13b9f45a5 --- /dev/null +++ b/tests/e2e/basic/performance_tests/client_scale_test/wpa3_personal/test_bridge_eap.py @@ -0,0 +1,555 @@ +""" + + Client Connectivity Enterprise TTLS + pytest -m "client_scale_test and bridge and enterprise and ttls" + +""" +import allure +import pytest + +pytestmark = [pytest.mark.performance, pytest.mark.bridge, pytest.mark.client_scale_tests] + +setup_params_general_2G = { + "mode": "BRIDGE", + "ssid_modes": { + "wpa3_enterprise": [ + {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["2G"]}, + ] + }, + + "rf": {}, + "radius": True +} + + +@allure.feature("Performance Test") +@allure.parent_suite("Client Scale Test") +@allure.suite("2.4 GHz Band") +@allure.sub_suite("BRIDGE Mode") +@pytest.mark.parametrize( + 'setup_configuration', + [setup_params_general_2G], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_configuration") +@pytest.mark.twog +@pytest.mark.wpa3_enterprise +class TestWifiCapacityEnterpriseBRIDGEMode2G(object): + @pytest.mark.wpa3_enterprise + @pytest.mark.twog + @pytest.mark.tcp_download + @allure.title("Test for TCP Download 2.4 GHz") + def test_client_wpa3_bridge_tcp_dl(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, + get_target_object, + num_stations, setup_configuration, check_connectivity, radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA3 Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA3 Enterprise security. + It focuses on the 2.4GHz band with TCP download traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, bridge, wpa3_enterprise, twog, tcp_download + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["2G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa3" + mode = "BRIDGE" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration, + key_mgmt="WPA-EAP-SHA256") + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa3_BRIDGE_tcp_dl_eap", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="0Gbps", protocol="TCP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"2G": max_stations},add_stations=False) + + @pytest.mark.wpa3_enterprise + @pytest.mark.twog + @pytest.mark.udp_download + @allure.title("Test for UDP Download 2.4 GHz") + def test_client_wpa3_bridge_udp_dl(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, + get_target_object, + num_stations, setup_configuration, check_connectivity, radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA3 Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA3 Enterprise security. + It focuses on the 2.4GHz band with UDP download traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, bridge, wpa3_enterprise, twog, udp_download + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["2G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa3" + mode = "BRIDGE" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration, + key_mgmt="WPA-EAP-SHA256") + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa3_BRIDGE_udp_dl_eap", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="0Gbps", protocol="TCP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"2G": max_stations},add_stations=False) + + @pytest.mark.wpa3_enterprise + @pytest.mark.twog + @pytest.mark.tcp_bidirectional + @allure.title("Test for TCP Bidirectional 2.4 GHz") + def test_client_wpa3_bridge_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, + get_target_object, + num_stations, setup_configuration, check_connectivity, radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA3 Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA3 Enterprise security. + It focuses on the 2.4GHz band with TCP download and upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, bridge, wpa3_enterprise, twog, tcp_bidirectional + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["2G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa3" + mode = "BRIDGE" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration, + key_mgmt="WPA-EAP-SHA256") + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa3_BRIDGE_tcp_bidirectional_eap", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="TCP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"2G": max_stations},add_stations=False) + + @pytest.mark.wpa3_enterprise + @pytest.mark.twog + @pytest.mark.udp_bidirectional + @allure.title("Test for UDP Bidirectional 2.4 GHz") + def test_client_wpa3_bridge_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, + get_target_object, + num_stations, setup_configuration, check_connectivity, radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA3 Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA3 Enterprise security. + It focuses on the 2.4GHz band with UDP download and upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, bridge, wpa3_enterprise, twog, tcp_bidirectional + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["2G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa3" + mode = "BRIDGE" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration, + key_mgmt="WPA-EAP-SHA256") + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa3_BRIDGE_udp_bidirectional_eap", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="UDP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"2G": max_stations},add_stations=False) + + @pytest.mark.wpa3_enterprise + @pytest.mark.twog + @pytest.mark.tcp_upload + @allure.title("Test for TCP Upload 2.4 GHz") + def test_client_wpa3_bridge_tcp_upload(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, + get_target_object, + num_stations, setup_configuration, check_connectivity, radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA3 Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA3 Enterprise security. + It focuses on the 2.4GHz band with TCP upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, bridge, wpa3_enterprise, twog, tcp_bidirectional + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["2G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa3" + mode = "BRIDGE" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration, + key_mgmt="WPA-EAP-SHA256") + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa3_BRIDGE_tcp_ul_eap", mode=mode, + download_rate="100Kbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="TCP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"2G": max_stations},add_stations=False) + + @pytest.mark.wpa3_enterprise + @pytest.mark.twog + @pytest.mark.udp_upload + @allure.title("Test for UDP Upload 2.4 GHz") + def test_client_wpa3_bridge_udp_upload(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, + get_target_object, + num_stations, setup_configuration, check_connectivity, radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA3 Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA3 Enterprise security. + It focuses on the 2.4GHz band with TCP upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, bridge, wpa3_enterprise, twog, tcp_bidirectional + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["2G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa3" + mode = "BRIDGE" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration, + key_mgmt="WPA-EAP-SHA256") + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa3_BRIDGE_udp_ul_eap", mode=mode, + download_rate="100Kbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="UDP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"2G": max_stations},add_stations=False) + +setup_params_general_5G = { + "mode": "BRIDGE", + "ssid_modes": { + "wpa3_enterprise": [ + {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["5G"]}, + ] + }, + "rf": {}, + "radius": True +} + +@allure.feature("Performance Test") +@allure.parent_suite("Client Scale Test") +@allure.suite("5 GHz Band") +@allure.sub_suite("BRIDGE Mode") +@pytest.mark.parametrize( + 'setup_configuration', + [setup_params_general_5G], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_configuration") +@pytest.mark.fiveg +@pytest.mark.wpa3_enterprise +class TestWifiCapacityEnterpriseBRIDGEMode5G(object): + @pytest.mark.wpa3_enterprise + @pytest.mark.fiveg + @pytest.mark.tcp_download + @allure.title("Test for TCP Download 5 GHz") + def test_client_wpa3_bridge_tcp_dl(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, + get_target_object, + num_stations, setup_configuration, check_connectivity, radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA3 Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA3 Enterprise security. + It focuses on the 5GHz band with TCP download traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, bridge, wpa3_enterprise, twog, tcp_download + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["5G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa3" + mode = "BRIDGE" + band = "fiveg" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration, + key_mgmt="WPA-EAP-SHA256") + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa3_BRIDGE_tcp_dl_eap", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="0Gbps", protocol="TCP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"5G": max_stations},add_stations=False) + + @pytest.mark.wpa3_enterprise + @pytest.mark.fiveg + @pytest.mark.udp_download + @allure.title("Test for UDP Download 5 GHz") + def test_client_wpa3_bridge_udp_dl(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, + get_target_object, + num_stations, setup_configuration, check_connectivity, radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA3 Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA3 Enterprise security. + It focuses on the 5GHz band with UDP download traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, bridge, wpa3_enterprise, twog, udp_download + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["5G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa3" + mode = "BRIDGE" + band = "fiveg" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration, + key_mgmt="WPA-EAP-SHA256") + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa3_BRIDGE_udp_dl_eap", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="0Gbps", protocol="TCP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"5G": max_stations},add_stations=False) + + @pytest.mark.wpa3_enterprise + @pytest.mark.fiveg + @pytest.mark.tcp_bidirectional + @allure.title("Test for TCP Bidirectional 5 GHz") + def test_client_wpa3_bridge_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, + get_target_object, + num_stations, setup_configuration, check_connectivity, radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA3 Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA3 Enterprise security. + It focuses on the 5GHz band with TCP download and upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, bridge, wpa3_enterprise, twog, tcp_bidirectional + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["5G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa3" + mode = "BRIDGE" + band = "fiveg" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration, + key_mgmt="WPA-EAP-SHA256") + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa3_BRIDGE_tcp_bidirectional_eap", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="TCP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"5G": max_stations},add_stations=False) + + @pytest.mark.wpa3_enterprise + @pytest.mark.twog + @pytest.mark.udp_bidirectional + @allure.title("Test for UDP Bidirectional 5 GHz") + def test_client_wpa3_bridge_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, + get_target_object, + num_stations, setup_configuration, check_connectivity, radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA3 Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA3 Enterprise security. + It focuses on the 5GHz band with UDP download and upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, bridge, wpa3_enterprise, twog, udp_bidirectional + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["5G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa3" + mode = "BRIDGE" + band = "fiveg" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration, + key_mgmt="WPA-EAP-SHA256") + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa3_BRIDGE_udp_bidirectional_eap", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="UDP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"5G": max_stations},add_stations=False) + + @pytest.mark.wpa3_enterprise + @pytest.mark.fiveg + @pytest.mark.tcp_upload + @allure.title("Test for TCP Upload 5 GHz") + def test_client_wpa3_bridge_tcp_upload(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, + get_target_object, + num_stations, setup_configuration, check_connectivity, radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA3 Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA3 Enterprise security. + It focuses on the 5GHz band with TCP upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, bridge, wpa3_enterprise, twog, tcp_upload + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["5G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa3" + mode = "BRIDGE" + band = "fiveg" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration, + key_mgmt="WPA-EAP-SHA256") + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa3_BRIDGE_tcp_ul_eap", mode=mode, + download_rate="100Kbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="TCP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"5G": max_stations},add_stations=False) + + @pytest.mark.wpa3_enterprise + @pytest.mark.fiveg + @pytest.mark.udp_upload + @allure.title("Test for UDP Upload 5 GHz") + def test_client_wpa3_bridge_udp_upload(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, + get_target_object, + num_stations, setup_configuration, check_connectivity, radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA3 Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA3 Enterprise security. + It focuses on the 2.4GHz band with TCP upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, bridge, wpa3_enterprise, twog, udp_upload + """ + get_test_library.pre_cleanup() + profile_data = {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["5G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa3" + mode = "BRIDGE" + band = "fiveg" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration, + key_mgmt="WPA-EAP-SHA256") + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa3_BRIDGE_udp_ul_eap", mode=mode, + download_rate="100Kbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="UDP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"5G": max_stations},add_stations=False) + diff --git a/tests/e2e/basic/performance_tests/client_scale_test/wpa_personal/test_bridge_eap.py b/tests/e2e/basic/performance_tests/client_scale_test/wpa_personal/test_bridge_eap.py new file mode 100644 index 000000000..a4ace8847 --- /dev/null +++ b/tests/e2e/basic/performance_tests/client_scale_test/wpa_personal/test_bridge_eap.py @@ -0,0 +1,567 @@ +""" + + Client Scale Test Enterprise TTLS + pytest -m "client_scale_tests and bridge and enterprise and performance" + +""" +import allure +import pytest + + +pytestmark = [pytest.mark.performance, pytest.mark.bridge, pytest.mark.client_scale_tests] + +setup_params_general_2G = { + "mode": "BRIDGE", + "ssid_modes": { + "wpa_enterprise": [ + {"ssid_name": "ssid_wpa_eap_2g", "appliedRadios": ["2G"]} + ] + }, + + "rf": {}, + "radius": True +} + + +@allure.feature("Performance Test") +@allure.parent_suite("Client Scale Test") +@allure.suite("2.4 GHz Band") +@allure.sub_suite("BRIDGE Mode") +@pytest.mark.parametrize( + 'setup_configuration', + [setup_params_general_2G], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_configuration") +@pytest.mark.wpa_enterprise +class TestWifiCapacityEnterpriseBRIDGEMode2G(object): + @pytest.mark.wpa_enterprise + @pytest.mark.twog + @pytest.mark.tcp_download + @allure.title("Test for TCP Download 2.4 GHz") + def test_client_wpa_bridge_tcp_dl(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, + get_target_object, + num_stations, setup_configuration, check_connectivity, radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA Enterprise security. + It focuses on the 2.4GHz band with TCP download traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, bridge, wpa_enterprise, twog, tcp_download + """ + profile_data = {"ssid_name": "ssid_wpa_eap_2g", "appliedRadios": ["2G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa" + extra_secu = ["wpa2"] + mode = "BRIDGE" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + extra_securities=extra_secu, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_tcp_dl_eap", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="0Gbps", protocol="TCP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"2G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa_enterprise + @pytest.mark.twog + @pytest.mark.udp_download + @allure.title("Test for UDP Download 2.4 GHz") + def test_client_wpa_bridge_udp_dl(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, + get_target_object, + num_stations, setup_configuration, check_connectivity, radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA Enterprise security. + It focuses on the 2.4GHz band with UDP download traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, bridge, wpa_enterprise, twog, tcp_download + """ + profile_data = {"ssid_name": "ssid_wpa_eap_2g", "appliedRadios": ["2G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa" + extra_secu = ["wpa2"] + mode = "BRIDGE" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + extra_securities=extra_secu, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa_BRIDGE_udp_dl_eap", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="0Gbps", protocol="UDP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"2G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa_enterprise + @pytest.mark.twog + @pytest.mark.tcp_bidirectional + @allure.title("Test for TCP Bidirectional 2.4 GHz") + def test_client_wpa_bridge_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, + get_target_object, + num_stations, setup_configuration, check_connectivity, radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA Enterprise security. + It focuses on the 2.4GHz band with TCP download and upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, bridge, wpa_enterprise, twog, tcp_download + """ + profile_data = {"ssid_name": "ssid_wpa_eap_2g", "appliedRadios": ["2G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa" + extra_secu = ["wpa2"] + mode = "BRIDGE" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + extra_securities=extra_secu, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa_BRIDGE_udp_dl_eap", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="TCP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"2G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa_enterprise + @pytest.mark.twog + @pytest.mark.udp_bidirectional + @allure.title("Test for UDP Bidirectional 2.4 GHz") + def test_client_wpa_bridge_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, + get_target_object, + num_stations, setup_configuration, check_connectivity, radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA Enterprise security. + It focuses on the 2.4GHz band with TCP download and upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, bridge, wpa_enterprise, twog, tcp_download + """ + profile_data = {"ssid_name": "ssid_wpa_eap_2g", "appliedRadios": ["2G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa" + extra_secu = ["wpa2"] + mode = "BRIDGE" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + extra_securities=extra_secu, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa_BRIDGE_udp_dl_eap", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="UDP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"2G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa_enterprise + @pytest.mark.twog + @pytest.mark.tcp_upload + @allure.title("Test for TCP Upload 2.4 GHz") + def test_client_wpa_bridge_tcp_upload(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, + get_target_object, + num_stations, setup_configuration, check_connectivity, radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA Enterprise security. + It focuses on the 2.4GHz band with TCP upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, bridge, wpa_enterprise, twog, tcp_download + """ + profile_data = {"ssid_name": "ssid_wpa_eap_2g", "appliedRadios": ["2G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa" + extra_secu = ["wpa2"] + mode = "BRIDGE" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + extra_securities=extra_secu, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa_BRIDGE_tcp_ul_eap", mode=mode, + download_rate="100Kbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="TCP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"2G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa_enterprise + @pytest.mark.twog + @pytest.mark.udp_upload + @allure.title("Test for UDP Upload 2.4 GHz") + def test_client_wpa_bridge_udp_upload(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, + get_target_object, + num_stations, setup_configuration, check_connectivity, radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA Enterprise security. + It focuses on the 2.4GHz band with UDP upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, bridge, wpa_enterprise, twog, tcp_download + """ + profile_data = {"ssid_name": "ssid_wpa_eap_2g", "appliedRadios": ["2G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa" + extra_secu = ["wpa2"] + mode = "BRIDGE" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + extra_securities=extra_secu, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa_BRIDGE_tcp_ul_eap", mode=mode, + download_rate="100Kbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="UDP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"2G": max_stations},add_stations=False) + assert True + +setup_params_general_5G = { + "mode": "BRIDGE", + "ssid_modes": { + "wpa_enterprise": [ + {"ssid_name": "ssid_wpa_eap_5g", "appliedRadios": ["5G"]} + ] + }, + + "rf": {}, + "radius": True +} + + +@allure.feature("Performance Test") +@allure.parent_suite("Client Scale Test") +@allure.suite("5 GHz Band") +@allure.sub_suite("BRIDGE Mode") +@pytest.mark.parametrize( + 'setup_configuration', + [setup_params_general_5G], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_configuration") +@pytest.mark.wpa_enterprise +class TestWifiCapacityEnterpriseBRIDGEMode5G(object): + @pytest.mark.wpa_enterprise + @pytest.mark.twog + @pytest.mark.tcp_download + @allure.title("Test for TCP Download 5 GHz") + def test_client_wpa_bridge_tcp_dl(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, + get_target_object, + num_stations, setup_configuration, check_connectivity, radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA Enterprise security. + It focuses on the 5GHz band with TCP download traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, bridge, wpa_enterprise, twog, tcp_download + """ + profile_data = {"ssid_name": "ssid_wpa_eap_5g", "appliedRadios": ["5G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa" + extra_secu = ["wpa2"] + mode = "BRIDGE" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + extra_securities=extra_secu, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_tcp_dl_eap", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="0Gbps", protocol="TCP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"5G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa_enterprise + @pytest.mark.twog + @pytest.mark.udp_download + @allure.title("Test for UDP Download 5 GHz") + def test_client_wpa_bridge_udp_dl(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, + get_target_object, + num_stations, setup_configuration, check_connectivity, radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA Enterprise security. + It focuses on the 2.4GHz band with UDP download traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, bridge, wpa_enterprise, twog, tcp_download + """ + profile_data = {"ssid_name": "ssid_wpa_eap_5g", "appliedRadios": ["5G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa" + extra_secu = ["wpa2"] + mode = "BRIDGE" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + extra_securities=extra_secu, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa_BRIDGE_udp_dl_eap", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="0Gbps", protocol="UDP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"5G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa_enterprise + @pytest.mark.twog + @pytest.mark.tcp_bidirectional + @allure.title("Test for TCP Bidirectional 5 GHz") + def test_client_wpa_bridge_tcp_bidirectional(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, + get_target_object, + num_stations, setup_configuration, check_connectivity, radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA Enterprise security. + It focuses on the 5GHz band with TCP download and upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, bridge, wpa_enterprise, twog, tcp_download + """ + profile_data = {"ssid_name": "ssid_wpa_eap_5g", "appliedRadios": ["5G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa" + extra_secu = ["wpa2"] + mode = "BRIDGE" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + extra_securities=extra_secu, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa_BRIDGE_udp_dl_eap", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="TCP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"5G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa_enterprise + @pytest.mark.twog + @pytest.mark.udp_bidirectional + @allure.title("Test for UDP Bidirectional 5 GHz") + def test_client_wpa_bridge_udp_bidirectional(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, + get_target_object, + num_stations, setup_configuration, check_connectivity, radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA Enterprise security. + It focuses on the 5GHz band with TCP download and upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, bridge, wpa_enterprise, twog, tcp_download + """ + profile_data = {"ssid_name": "ssid_wpa_eap_5g", "appliedRadios": ["5G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa" + extra_secu = ["wpa2"] + mode = "BRIDGE" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + extra_securities=extra_secu, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa_BRIDGE_udp_dl_eap", mode=mode, + download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="UDP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"5G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa_enterprise + @pytest.mark.twog + @pytest.mark.tcp_upload + @allure.title("Test for TCP Upload 5 GHz") + def test_client_wpa_bridge_tcp_upload(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, + get_target_object, + num_stations, setup_configuration, check_connectivity, radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA Enterprise security. + It focuses on the 5GHz band with TCP upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, bridge, wpa_enterprise, twog, tcp_download + """ + profile_data = {"ssid_name": "ssid_wpa_eap_5g", "appliedRadios": ["5G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa" + extra_secu = ["wpa2"] + mode = "BRIDGE" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + extra_securities=extra_secu, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa_BRIDGE_tcp_ul_eap", mode=mode, + download_rate="100Kbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="TCP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"5G": max_stations},add_stations=False) + assert True + + @pytest.mark.wpa_enterprise + @pytest.mark.twog + @pytest.mark.udp_upload + @allure.title("Test for UDP Upload 5 GHz") + def test_client_wpa_bridge_udp_upload(self, get_test_library, get_dut_logs_per_test_case, + get_test_device_logs, + get_target_object, + num_stations, setup_configuration, check_connectivity, radius_info,max_stations): + """ + Client Scale Test - BRIDGE mode with WPA Enterprise Security + + This test evaluates the scalability and performance of a network in BRIDGE mode using WPA Enterprise security. + It focuses on the 5GHz band with UDP upload traffic, validating client connectivity, throughput, and stability + as the number of clients increases. + + **Markers**: performance, client_scale_tests, bridge, wpa_enterprise, twog, tcp_download + """ + profile_data = {"ssid_name": "ssid_wpa_eap_5g", "appliedRadios": ["5G"]} + ssid_name = profile_data["ssid_name"] + security = "wpa" + extra_secu = ["wpa2"] + mode = "BRIDGE" + band = "twog" + ttls_passwd = "password" + eap = "TTLS" + identity = "testing" + passes, result = get_test_library.enterprise_client_connectivity_test(ssid=ssid_name, security=security, + extra_securities=extra_secu, + mode=mode, band=band, eap=eap, + ttls_passwd=ttls_passwd, + identity=identity, num_sta=max_stations, + dut_data=setup_configuration) + if passes != "PASS": + assert passes == "PASS", result + if passes == "PASS": + get_test_library.wifi_capacity(instance_name="test_client_wpa_BRIDGE_tcp_ul_eap", mode=mode, + download_rate="100Kbps", batch_size="1,5,10,20,40,64,128,256", + upload_rate="1Gbps", protocol="UDP", duration="60000", + move_to_influx=False, dut_data=setup_configuration, ssid_name=ssid_name, + num_stations={"5G": max_stations},add_stations=False) + assert True \ No newline at end of file