scottk/wlan-testing
1
0
Fork 0
mirror of https://github.com/Telecominfraproject/wlan-testing.git synced 2025-11-02 11:57:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

Added client scale test and AX capacity test

Browse Source
This commit is contained in:
jitendracandela
2025-01-02 10:27:06 +05:30
parent 953b8f1170
commit 4c312bedf4
7 changed files with 4187 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

690
tests/e2e/basic/performance_tests/AX_capacity/wpa2_personal/test_bridge_eap.py Normal file
View File

@@ -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

606
tests/e2e/basic/performance_tests/AX_capacity/wpa2_personal/test_eap_vlan_mode.py Normal file
View File

@@ -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

589
tests/e2e/basic/performance_tests/AX_capacity/wpa2_personal/test_nat_eap.py Normal file
View File

@@ -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

636
tests/e2e/basic/performance_tests/client_scale_test/wpa2_personal/test_bridge_eap.py Normal file
View File

@@ -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

544
tests/e2e/basic/performance_tests/client_scale_test/wpa2_personal/test_nat_eap.py Normal file
View File

@@ -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

555
tests/e2e/basic/performance_tests/client_scale_test/wpa3_personal/test_bridge_eap.py Normal file
View File

@@ -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)

567
tests/e2e/basic/performance_tests/client_scale_test/wpa_personal/test_bridge_eap.py Normal file
View File

@@ -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