From ad2d43f42acd33bf5151e621cc5ca83686b189c6 Mon Sep 17 00:00:00 2001 From: Sushant Date: Thu, 29 Apr 2021 19:09:49 +0530 Subject: [PATCH 01/21] added basic chamber view setup Signed-off-by: Sushant --- tests/conftest.py | 36 ++++++++++++++-- .../_basic_test_setup/setup__e2e_resources.py | 10 +++++ tests/e2e/basic/conftest.py | 42 +++++++++++++++++-- tests/test_connectivity.py | 2 +- 4 files changed, 83 insertions(+), 7 deletions(-) diff --git a/tests/conftest.py b/tests/conftest.py index a5f3c0447..34ddbc36f 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -4,6 +4,21 @@ import sys import os import time +for folder in 'py-json', 'py-scripts': + if folder not in sys.path: + sys.path.append(f'../lanforge/lanforge-scripts/{folder}') + +sys.path.append(f"../lanforge/lanforge-scripts/py-scripts/tip-cicd-sanity") + +sys.path.append(f'../libs') +sys.path.append(f'../libs/lanforge/') + +from LANforge.LFUtils import * + +if 'py-json' not in sys.path: + sys.path.append('../py-scripts') + + sys.path.append( os.path.dirname( os.path.realpath(__file__) @@ -24,7 +39,7 @@ from configuration import CONFIGURATION from configuration import FIRMWARE from testrails.testrail_api import APIClient from testrails.reporting import Reporting - +from cv_test_manager import cv_test def pytest_addoption(parser): parser.addini("tr_url", "Test Rail URL") @@ -159,8 +174,23 @@ def instantiate_project(request, instantiate_testrail, testbed, get_latest_firmw @pytest.fixture(scope="session") -def setup_lanforge(): - yield True +def check_lanforge_connectivity(testbed): + lanforge_ip = CONFIGURATION[testbed]['traffic_generator']['details']['ip'] + lanforge_port = CONFIGURATION[testbed]['traffic_generator']['details']['port'] + + try: + cv = cv_test(lanforge_ip,lanforge_port) + url_data = cv.get_ports("/") + lanforge_GUI_version = url_data["VersionInfo"]["BuildVersion"] + lanforge_gui_git_version = url_data["VersionInfo"]["GitVersion"] + lanforge_gui_build_date = url_data["VersionInfo"]["BuildDate"] + print(lanforge_GUI_version,lanforge_gui_build_date,lanforge_gui_git_version) + if not (lanforge_GUI_version or lanforge_gui_build_date or lanforge_gui_git_version): + yield False + else: + yield True + except: + yield False @pytest.fixture(scope="session") diff --git a/tests/e2e/basic/_basic_test_setup/setup__e2e_resources.py b/tests/e2e/basic/_basic_test_setup/setup__e2e_resources.py index bcf20b0e1..b820a5408 100644 --- a/tests/e2e/basic/_basic_test_setup/setup__e2e_resources.py +++ b/tests/e2e/basic/_basic_test_setup/setup__e2e_resources.py @@ -6,6 +6,15 @@ import pytest +@pytest.mark.lanforge_scenario_setup +def test_lanforge_scenario_setup(create_lanforge_chamberview): + raw_line = [ + ["profile_link 1.1 vlan-100 1 NA NA eth2,AUTO -1 100"] + ] + print(create_lanforge_chamberview.setup(create_scenario="TIP-test",raw_line=raw_line)) + create_lanforge_chamberview.build("TIP-test") + assert True + @pytest.mark.sanity @pytest.mark.bridge @pytest.mark.nat @@ -74,3 +83,4 @@ def test_ap_firmware(check_ap_firmware_ssh, get_latest_firmware, instantiate_tes msg='Cannot reach AP after upgrade to check CLI - re-test required') assert check_ap_firmware_ssh == get_latest_firmware + diff --git a/tests/e2e/basic/conftest.py b/tests/e2e/basic/conftest.py index 1e0c4984d..55df9089d 100644 --- a/tests/e2e/basic/conftest.py +++ b/tests/e2e/basic/conftest.py @@ -29,6 +29,21 @@ import sys import os import time +for folder in 'py-json', 'py-scripts': + if folder not in sys.path: + sys.path.append(f'../lanforge/lanforge-scripts/{folder}') + +sys.path.append(f"../lanforge/lanforge-scripts/py-scripts/tip-cicd-sanity") + +sys.path.append(f'../libs') +sys.path.append(f'../libs/lanforge/') + +from LANforge.LFUtils import * + +if 'py-json' not in sys.path: + sys.path.append('../py-scripts') + + sys.path.append( os.path.dirname( os.path.realpath(__file__) @@ -49,14 +64,14 @@ from configuration import CONFIGURATION from configuration import FIRMWARE from testrails.testrail_api import APIClient from testrails.reporting import Reporting - - +from cv_test_manager import cv_test +from create_chamberview import CreateChamberview """ Basic Setup Collector """ -@pytest.fixture(scope="function") +@pytest.fixture(scope="session") def get_lanforge_data(testbed): lanforge_data = {} if CONFIGURATION[testbed]['traffic_generator']['name'] == 'lanforge': @@ -304,3 +319,24 @@ def update_ssid(request, instantiate_profile, setup_profile_data): requested_profile[3] time.sleep(90) yield status + +@pytest.fixture(scope="package") +def create_lanforge_chamberview(get_lanforge_data): + ip = get_lanforge_data["lanforge_ip"] + port = get_lanforge_data["lanforge-port-number"] + upstream_port = get_lanforge_data["lanforge_bridge_port"]#eth2 + eth_vlan = get_lanforge_data["lanforge_vlan_port"]#eth2.100 + vlan = get_lanforge_data["vlan"] + scenario_name = "TIP-test" + # "profile_link 1.1 upstream-dhcp 1 NA NA eth2,AUTO -1 NA" + # "profile_link 1.1 uplink-nat 1 'DUT: upstream LAN 10.28.2.1/24' NA eth1,eth2 -1 NA" + raw_line = [ + ["profile_link 1.1 upstream-dhcp 1 NA NA eth2,AUTO -1 NA"], + ["profile_link 1.1 uplink-nat 1 'DUT: upstream LAN 10.28.2.1/24' NA eth1,eth2 -1 NA"] + ] + Create_Chamberview = CreateChamberview(ip, port) + Create_Chamberview.setup(create_scenario=scenario_name, + raw_line=raw_line) + + Create_Chamberview.build(scenario_name) + yield Create_Chamberview diff --git a/tests/test_connectivity.py b/tests/test_connectivity.py index 709b5faaa..e3f1e94b8 100644 --- a/tests/test_connectivity.py +++ b/tests/test_connectivity.py @@ -42,7 +42,7 @@ def test_access_points_connectivity(test_access_point, instantiate_testrail, ins @pytest.mark.test_lanforge_connectivity -def test_lanforge_connectivity(setup_lanforge): +def test_lanforge_connectivity(check_lanforge_connectivity): assert "instantiate_cloudsdk" From 69e95080ceacec615ccbc6f36836cd14455b0314 Mon Sep 17 00:00:00 2001 From: sushant Date: Mon, 10 May 2021 10:49:04 +0530 Subject: [PATCH 02/21] marker and fixture added for DUT and chamberview scenario --- .../_basic_test_setup/setup__e2e_resources.py | 30 ++++++++++++++--- tests/e2e/basic/conftest.py | 32 ++++++++++++++++--- 2 files changed, 53 insertions(+), 9 deletions(-) diff --git a/tests/e2e/basic/_basic_test_setup/setup__e2e_resources.py b/tests/e2e/basic/_basic_test_setup/setup__e2e_resources.py index b820a5408..52b6631e4 100644 --- a/tests/e2e/basic/_basic_test_setup/setup__e2e_resources.py +++ b/tests/e2e/basic/_basic_test_setup/setup__e2e_resources.py @@ -4,15 +4,35 @@ """ import pytest +import time +@pytest.mark.lanforge_scenario_setup_dut +def test_lanforge_scenario_setup_dut(create_lanforge_chamberview_dut): + print(create_lanforge_chamberview_dut) + ssid = [ + ['ssid_idx=0 ssid=Default-SSID-2g password=12345678 bssid=90:3c:b3:94:48:58'], + ['ssid_idx=1 ssid=Default-SSID-5gl password=12345678 bssid=90:3c:b3:94:48:59'] + ] + + create_lanforge_chamberview_dut.ssid = ssid + create_lanforge_chamberview_dut.setup() + create_lanforge_chamberview_dut.add_ssids() + create_lanforge_chamberview_dut.cv_test.show_text_blob(None, None, True) # Show changes on GUI + create_lanforge_chamberview_dut.cv_test.sync_cv() + time.sleep(2) + create_lanforge_chamberview_dut.cv_test.show_text_blob(None, None, True) # Show changes on GUI + create_lanforge_chamberview_dut.cv_test.sync_cv() + + assert True + @pytest.mark.lanforge_scenario_setup def test_lanforge_scenario_setup(create_lanforge_chamberview): - raw_line = [ - ["profile_link 1.1 vlan-100 1 NA NA eth2,AUTO -1 100"] - ] - print(create_lanforge_chamberview.setup(create_scenario="TIP-test",raw_line=raw_line)) - create_lanforge_chamberview.build("TIP-test") + # raw_line = [ + # ["profile_link 1.1 vlan-100 1 NA NA eth2,AUTO -1 100"] + # ] + # print(create_lanforge_chamberview.setup_scenario(create_scenario="TIP-test",raw_line=raw_line)) + # create_lanforge_chamberview.build_scenario("TIP-test") assert True @pytest.mark.sanity diff --git a/tests/e2e/basic/conftest.py b/tests/e2e/basic/conftest.py index 55df9089d..5ec03ab10 100644 --- a/tests/e2e/basic/conftest.py +++ b/tests/e2e/basic/conftest.py @@ -66,6 +66,8 @@ from testrails.testrail_api import APIClient from testrails.reporting import Reporting from cv_test_manager import cv_test from create_chamberview import CreateChamberview +from create_chamberview_dut import DUT + """ Basic Setup Collector """ @@ -328,15 +330,37 @@ def create_lanforge_chamberview(get_lanforge_data): eth_vlan = get_lanforge_data["lanforge_vlan_port"]#eth2.100 vlan = get_lanforge_data["vlan"] scenario_name = "TIP-test" + + print(ip) + print(upstream_port) + print(eth_vlan) + print(vlan) # "profile_link 1.1 upstream-dhcp 1 NA NA eth2,AUTO -1 NA" # "profile_link 1.1 uplink-nat 1 'DUT: upstream LAN 10.28.2.1/24' NA eth1,eth2 -1 NA" raw_line = [ - ["profile_link 1.1 upstream-dhcp 1 NA NA eth2,AUTO -1 NA"], - ["profile_link 1.1 uplink-nat 1 'DUT: upstream LAN 10.28.2.1/24' NA eth1,eth2 -1 NA"] + ["profile_link 1.1 upstream-dhcp 1 NA NA "+ upstream_port +",AUTO -1 NA"] + # ["profile_link 1.1 uplink-nat 1 'DUT: upstream LAN 10.28.2.1/24' NA eth1,eth2 -1 NA"] ] Create_Chamberview = CreateChamberview(ip, port) - Create_Chamberview.setup(create_scenario=scenario_name, + Create_Chamberview.clean_cv_scenario(type="Network-Connectivity", scenario_name=scenario_name) + + Create_Chamberview.setup_scenario(create_scenario=scenario_name, raw_line=raw_line) - Create_Chamberview.build(scenario_name) + Create_Chamberview.build_scenario(scenario_name) + Create_Chamberview.show_text_blob(None, None, True) # Show changes on GUI yield Create_Chamberview + + +@pytest.fixture(scope="package") +def create_lanforge_chamberview_dut(get_lanforge_data): + ip = get_lanforge_data["lanforge_ip"] + port = get_lanforge_data["lanforge-port-number"] + dut = DUT(lfmgr=ip, + port=port, + dut_name="TIP-Test", + sw_version="pending-d89798e", + hw_version="ECW5410", + model_num="ECW5410" + ) + yield dut From bbefdf10562d5f7b8dfd1720025b40af9085a726 Mon Sep 17 00:00:00 2001 From: shivamcandela Date: Tue, 11 May 2021 14:15:12 +0530 Subject: [PATCH 03/21] Adding framework support for multi ap support Signed-off-by: shivamcandela --- libs/apnos/apnos.py | 5 +- libs/apnos/openwrt_ctl.py | 1 + libs/controller/controller.py | 169 +++-- libs/testrails/reporting.py | 3 +- libs/testrails/testrail_api.py | 4 +- tests/conftest.py | 122 ++-- .../bridge/__init__.py | 0 .../bridge/basic_security_modes/__init__.py | 0 .../test__configuration_basic_modes.py | 91 +++ .../test_basic_security.py | 124 ++++ .../enterprise_security_modes/__init__.py | 0 .../test_configuration_enterprise_modes.py | 55 ++ .../test_enterprise_security.py | 55 ++ .../client_connectivity_test/conftest.py | 344 ++++++++++ .../client_connectivity_test/nat/__init__.py | 0 .../nat/basic_security_modes/__init__.py | 0 .../test_basic_security.py | 78 +++ .../test_configuration_basic_modes.py | 78 +++ .../nat/enterprise_security_modes/__init__.py | 0 .../test_configuration_enterprise_modes.py | 55 ++ .../test_enterprise_security.py | 55 ++ .../test_bridge_mode.py | 379 ----------- .../client_connectivity_test/test_nat_mode.py | 378 ----------- .../test_vlan_mode.py | 376 ----------- .../client_connectivity_test/vlan/__init__.py | 0 .../vlan/basic_security_modes/__init__.py | 0 .../test_basic_security.py | 78 +++ .../test_configuration_basic_modes.py | 78 +++ .../enterprise_security_modes/__init__.py | 0 .../test_configuration_enterprise_modes.py | 55 ++ .../test_enterprise_security.py | 55 ++ tests/e2e/basic/conftest.py | 614 +++++++++--------- tests/pytest.ini | 2 +- tests/test_connectivity.py | 4 +- 34 files changed, 1696 insertions(+), 1562 deletions(-) create mode 100644 tests/e2e/basic/client_connectivity_test/bridge/__init__.py create mode 100644 tests/e2e/basic/client_connectivity_test/bridge/basic_security_modes/__init__.py create mode 100644 tests/e2e/basic/client_connectivity_test/bridge/basic_security_modes/test__configuration_basic_modes.py create mode 100644 tests/e2e/basic/client_connectivity_test/bridge/basic_security_modes/test_basic_security.py create mode 100644 tests/e2e/basic/client_connectivity_test/bridge/enterprise_security_modes/__init__.py create mode 100644 tests/e2e/basic/client_connectivity_test/bridge/enterprise_security_modes/test_configuration_enterprise_modes.py create mode 100644 tests/e2e/basic/client_connectivity_test/bridge/enterprise_security_modes/test_enterprise_security.py create mode 100644 tests/e2e/basic/client_connectivity_test/conftest.py create mode 100644 tests/e2e/basic/client_connectivity_test/nat/__init__.py create mode 100644 tests/e2e/basic/client_connectivity_test/nat/basic_security_modes/__init__.py create mode 100644 tests/e2e/basic/client_connectivity_test/nat/basic_security_modes/test_basic_security.py create mode 100644 tests/e2e/basic/client_connectivity_test/nat/basic_security_modes/test_configuration_basic_modes.py create mode 100644 tests/e2e/basic/client_connectivity_test/nat/enterprise_security_modes/__init__.py create mode 100644 tests/e2e/basic/client_connectivity_test/nat/enterprise_security_modes/test_configuration_enterprise_modes.py create mode 100644 tests/e2e/basic/client_connectivity_test/nat/enterprise_security_modes/test_enterprise_security.py delete mode 100644 tests/e2e/basic/client_connectivity_test/test_bridge_mode.py delete mode 100644 tests/e2e/basic/client_connectivity_test/test_nat_mode.py delete mode 100644 tests/e2e/basic/client_connectivity_test/test_vlan_mode.py create mode 100644 tests/e2e/basic/client_connectivity_test/vlan/__init__.py create mode 100644 tests/e2e/basic/client_connectivity_test/vlan/basic_security_modes/__init__.py create mode 100644 tests/e2e/basic/client_connectivity_test/vlan/basic_security_modes/test_basic_security.py create mode 100644 tests/e2e/basic/client_connectivity_test/vlan/basic_security_modes/test_configuration_basic_modes.py create mode 100644 tests/e2e/basic/client_connectivity_test/vlan/enterprise_security_modes/__init__.py create mode 100644 tests/e2e/basic/client_connectivity_test/vlan/enterprise_security_modes/test_configuration_enterprise_modes.py create mode 100644 tests/e2e/basic/client_connectivity_test/vlan/enterprise_security_modes/test_enterprise_security.py diff --git a/libs/apnos/apnos.py b/libs/apnos/apnos.py index 77ffa7147..89352fd37 100644 --- a/libs/apnos/apnos.py +++ b/libs/apnos/apnos.py @@ -13,6 +13,7 @@ Currently Having Methods: import paramiko from scp import SCPClient import os +import allure class APNOS: @@ -39,7 +40,7 @@ class APNOS: if str(stdout.read()).__contains__("False"): print("Copying openwrt_ctl serial control Script...") with SCPClient(client.get_transport()) as scp: - scp.put(pwd+'openwrt_ctl.py', '~/cicd-git/openwrt_ctl.py') # Copy my_file.txt to the server + scp.put(pwd + 'openwrt_ctl.py', '~/cicd-git/openwrt_ctl.py') # Copy my_file.txt to the server cmd = '[ -f ~/cicd-git/openwrt_ctl.py ] && echo "True" || echo "False"' stdin, stdout, stderr = client.exec_command(cmd) var = str(stdout.read()) @@ -79,6 +80,8 @@ class APNOS: f"cmd --value \"{cmd}\" " stdin, stdout, stderr = client.exec_command(cmd) output = stdout.read() + allure.attach(body=str("VIF Config: " + str(vif_config) + "\n" + "VIF State: " + str(vif_state)), + name="SSID Profiles in VIF Config and VIF State: ") client.close() return output diff --git a/libs/apnos/openwrt_ctl.py b/libs/apnos/openwrt_ctl.py index 60d102892..d7b849389 100755 --- a/libs/apnos/openwrt_ctl.py +++ b/libs/apnos/openwrt_ctl.py @@ -5,6 +5,7 @@ make sure pexpect is installed: $ sudo yum install python3-pexpect You might need to install pexpect-serial using pip: +$ pip3 install serial $ pip3 install pexpect-serial ./openwrt_ctl.py -l stdout -u root -p TIP -s serial --tty ttyUSB0 diff --git a/libs/controller/controller.py b/libs/controller/controller.py index 0ad3e9ab3..1b72bcfa0 100644 --- a/libs/controller/controller.py +++ b/libs/controller/controller.py @@ -93,7 +93,7 @@ class Controller(ConfigureController): self.api_client.configuration.api_key_prefix = { "Authorization": "Bearer " + self.bearer._access_token } - self.api_client.configuration.refresh_api_key_hook = self.get_bearer_token() + self.api_client.configuration.refresh_api_key_hook = self.refresh_instance self.ping_response = self.portal_ping() self.default_profiles = {} # print(self.bearer) @@ -122,7 +122,7 @@ class Controller(ConfigureController): self.api_client.configuration.api_key_prefix = { "Authorization": "Bearer " + self.bearer._access_token } - self.api_client.configuration.refresh_api_key_hook = self.get_bearer_token() + self.api_client.configuration.refresh_api_key_hook = self.refresh_instance self.ping_response = self.portal_ping() self.default_profiles = {} # print(self.bearer) @@ -451,21 +451,16 @@ class ProfileUtility: method call: used to create a ssid profile with the given parameters """ - def create_open_ssid_profile(self, two4g=True, fiveg=True, profile_data=None): + def create_open_ssid_profile(self, profile_data=None): try: if profile_data is None: return False default_profile = self.default_profiles['ssid'] - default_profile._details['appliedRadios'] = [] - if two4g is True: - default_profile._details['appliedRadios'].append("is2dot4GHz") - if fiveg is True: - default_profile._details['appliedRadios'].append("is5GHzU") - default_profile._details['appliedRadios'].append("is5GHz") - default_profile._details['appliedRadios'].append("is5GHzL") + default_profile._details['appliedRadios'] = profile_data["appliedRadios"] + default_profile._name = profile_data['profile_name'] - default_profile._details['vlanId'] = profile_data['vlan'] default_profile._details['ssid'] = profile_data['ssid_name'] + default_profile._details['vlanId'] = profile_data['vlan'] default_profile._details['forwardMode'] = profile_data['mode'] default_profile._details['secureMode'] = 'open' profile = self.profile_client.create_profile(body=default_profile) @@ -473,22 +468,17 @@ class ProfileUtility: self.profile_creation_ids['ssid'].append(profile_id) self.profile_ids.append(profile_id) except Exception as e: + print(e) profile = "error" return profile - def create_wpa_ssid_profile(self, two4g=True, fiveg=True, profile_data=None): + def create_wpa_ssid_profile(self, profile_data=None): try: if profile_data is None: return False default_profile = self.default_profiles['ssid'] - default_profile._details['appliedRadios'] = [] - if two4g is True: - default_profile._details['appliedRadios'].append("is2dot4GHz") - if fiveg is True: - default_profile._details['appliedRadios'].append("is5GHzU") - default_profile._details['appliedRadios'].append("is5GHz") - default_profile._details['appliedRadios'].append("is5GHzL") + default_profile._details['appliedRadios'] = profile_data["appliedRadios"] default_profile._name = profile_data['profile_name'] default_profile._details['vlanId'] = profile_data['vlan'] default_profile._details['ssid'] = profile_data['ssid_name'] @@ -500,21 +490,17 @@ class ProfileUtility: self.profile_creation_ids['ssid'].append(profile_id) self.profile_ids.append(profile_id) except Exception as e: + print(e) profile = False return profile - def create_wpa2_personal_ssid_profile(self, two4g=True, fiveg=True, profile_data=None): + def create_wpa2_personal_ssid_profile(self, profile_data=None): try: if profile_data is None: return False default_profile = self.default_profiles['ssid'] - default_profile._details['appliedRadios'] = [] - if two4g is True: - default_profile._details['appliedRadios'].append("is2dot4GHz") - if fiveg is True: - default_profile._details['appliedRadios'].append("is5GHzU") - default_profile._details['appliedRadios'].append("is5GHz") - default_profile._details['appliedRadios'].append("is5GHzL") + default_profile._details['appliedRadios'] = profile_data["appliedRadios"] + default_profile._name = profile_data['profile_name'] default_profile._details['vlanId'] = profile_data['vlan'] default_profile._details['ssid'] = profile_data['ssid_name'] @@ -526,43 +512,39 @@ class ProfileUtility: self.profile_creation_ids['ssid'].append(profile_id) self.profile_ids.append(profile_id) except Exception as e: + print(e) profile = False return profile - def create_wpa3_personal_ssid_profile(self, two4g=True, fiveg=True, profile_data=None): - if profile_data is None: - return False - default_profile = self.default_profiles['ssid'] - default_profile._details['appliedRadios'] = [] - if two4g is True: - default_profile._details['appliedRadios'].append("is2dot4GHz") - if fiveg is True: - default_profile._details['appliedRadios'].append("is5GHzU") - default_profile._details['appliedRadios'].append("is5GHz") - default_profile._details['appliedRadios'].append("is5GHzL") - default_profile._name = profile_data['profile_name'] - default_profile._details['vlanId'] = profile_data['vlan'] - default_profile._details['ssid'] = profile_data['ssid_name'] - default_profile._details['keyStr'] = profile_data['security_key'] - default_profile._details['forwardMode'] = profile_data['mode'] - default_profile._details['secureMode'] = 'wpa3OnlyPSK' - profile_id = self.profile_client.create_profile(body=default_profile)._id - self.profile_creation_ids['ssid'].append(profile_id) - self.profile_ids.append(profile_id) - return True - - def create_wpa2_enterprise_ssid_profile(self, two4g=True, fiveg=True, profile_data=None): + def create_wpa3_personal_ssid_profile(self, profile_data=None): try: if profile_data is None: return False default_profile = self.default_profiles['ssid'] - default_profile._details['appliedRadios'] = [] - if two4g is True: - default_profile._details['appliedRadios'].append("is2dot4GHz") - if fiveg is True: - default_profile._details['appliedRadios'].append("is5GHzU") - default_profile._details['appliedRadios'].append("is5GHz") - default_profile._details['appliedRadios'].append("is5GHzL") + default_profile._details['appliedRadios'] = profile_data["appliedRadios"] + + default_profile._name = profile_data['profile_name'] + default_profile._details['vlanId'] = profile_data['vlan'] + default_profile._details['ssid'] = profile_data['ssid_name'] + default_profile._details['keyStr'] = profile_data['security_key'] + default_profile._details['forwardMode'] = profile_data['mode'] + default_profile._details['secureMode'] = 'wpa3OnlyPSK' + profile = self.profile_client.create_profile(body=default_profile) + profile_id = profile._id + self.profile_creation_ids['ssid'].append(profile_id) + self.profile_ids.append(profile_id) + except Exception as e: + print(e) + profile = False + return profile + + def create_wpa2_enterprise_ssid_profile(self, profile_data=None): + try: + if profile_data is None: + return False + default_profile = self.default_profiles['ssid'] + default_profile._details['appliedRadios'] = profile_data["appliedRadios"] + default_profile._name = profile_data['profile_name'] default_profile._details['vlanId'] = profile_data['vlan'] default_profile._details['ssid'] = profile_data['ssid_name'] @@ -579,29 +561,27 @@ class ProfileUtility: profile = False return profile - def create_wpa3_enterprise_ssid_profile(self, two4g=True, fiveg=True, profile_data=None): - if profile_data is None: - return False - default_profile = self.default_profiles['ssid'] - default_profile._details['appliedRadios'] = [] - if two4g is True: - default_profile._details['appliedRadios'].append("is2dot4GHz") - if fiveg is True: - default_profile._details['appliedRadios'].append("is5GHzU") - default_profile._details['appliedRadios'].append("is5GHz") - default_profile._details['appliedRadios'].append("is5GHzL") - default_profile._name = profile_data['profile_name'] - default_profile._details['vlanId'] = profile_data['vlan'] - default_profile._details['ssid'] = profile_data['ssid_name'] - default_profile._details['keyStr'] = profile_data['security_key'] - default_profile._details['forwardMode'] = profile_data['mode'] - default_profile._details['secureMode'] = 'wpa3OnlyRadius' - default_profile._details["radiusServiceId"] = self.profile_creation_ids["radius"][0] - default_profile._child_profile_ids = self.profile_creation_ids["radius"] - profile_id = self.profile_client.create_profile(body=default_profile)._id - self.profile_creation_ids['ssid'].append(profile_id) - self.profile_ids.append(profile_id) - return True + def create_wpa3_enterprise_ssid_profile(self, profile_data=None): + try: + if profile_data is None: + return False + default_profile = self.default_profiles['ssid'] + default_profile._details['appliedRadios'] = profile_data["appliedRadios"] + default_profile._name = profile_data['profile_name'] + default_profile._details['vlanId'] = profile_data['vlan'] + default_profile._details['ssid'] = profile_data['ssid_name'] + default_profile._details['forwardMode'] = profile_data['mode'] + default_profile._details["radiusServiceId"] = self.profile_creation_ids["radius"][0] + default_profile._child_profile_ids = self.profile_creation_ids["radius"] + default_profile._details['secureMode'] = 'wpa3OnlyEAP' + profile = self.profile_client.create_profile(body=default_profile) + profile_id = profile._id + self.profile_creation_ids['ssid'].append(profile_id) + self.profile_ids.append(profile_id) + except Exception as e: + print(e) + profile = False + return profile """ method call: used to create a ap profile that contains the given ssid profiles @@ -728,17 +708,17 @@ class JFrogUtility: def get_build(self, model=None, version=None): jfrog_url = self.jfrog_url + "/" + model + "/" + self.branch + "/" - auth = str( - base64.b64encode( - bytes('%s:%s' % (self.user, self.password), 'utf-8') - ), - 'ascii' - ).strip() - headers = {'Authorization': 'Basic ' + auth} + # auth = str( + # base64.b64encode( + # bytes('%s:%s' % (self.user, self.password), 'utf-8') + # ), + # 'ascii' + # ).strip() + # headers = {'Authorization': 'Basic ' + auth} ''' FIND THE LATEST FILE NAME''' print(jfrog_url) - req = urllib.request.Request(jfrog_url, headers=headers) + req = urllib.request.Request(jfrog_url) response = urllib.request.urlopen(req) # print(response) html = response.read() @@ -857,3 +837,16 @@ class FirmwareUtility(JFrogUtility): firmware_version = False print("firmware not available: ", firmware_version) return firmware_version +controller = { + 'url': "https://wlan-portal-svc-nola-ext-03.cicd.lab.wlan.tip.build", # API base url for the controller + 'username': 'support@example.com', + 'password': 'support', + 'version': "1.1.0-SNAPSHOT", + 'commit_date': "2021-04-27" +} +api = Controller(controller_data=controller) +for i in range(0, 2500): + print(i) + time.sleep(1) +print(api.get_equipment_by_customer_id()) +api.disconnect_Controller() \ No newline at end of file diff --git a/libs/testrails/reporting.py b/libs/testrails/reporting.py index 849c06082..ac2e922a3 100644 --- a/libs/testrails/reporting.py +++ b/libs/testrails/reporting.py @@ -1,7 +1,8 @@ class Reporting: def __init__(self): + self.rid = None pass def update_testrail(self, case_id=None, run_id=None, status_id=1, msg=None): - pass \ No newline at end of file + pass diff --git a/libs/testrails/testrail_api.py b/libs/testrails/testrail_api.py index f8a01019d..d25afe6af 100644 --- a/libs/testrails/testrail_api.py +++ b/libs/testrails/testrail_api.py @@ -27,6 +27,7 @@ class APIClient: self.user = tr_user self.password = tr_pw self.project = project + self.rid = None if not base_url.endswith('/'): base_url += '/' self.__url = base_url + 'index.php?/api/v2/' @@ -148,9 +149,10 @@ class APIClient: break return run_id - def update_testrail(self, case_id, run_id, status_id, msg): + def update_testrail(self, case_id, status_id, msg): "Update TestRail for a given run_id and case_id" update_flag = False + run_id = self.rid # Get the TestRail client account details # Update the result in TestRail using send_post function. # Parameters for add_result_for_case is the combination of runid and case id. diff --git a/tests/conftest.py b/tests/conftest.py index 50e0be8ad..e683dfe37 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -3,6 +3,7 @@ import datetime import sys import os import time +import allure sys.path.append( os.path.dirname( @@ -11,7 +12,19 @@ sys.path.append( ) if "libs" not in sys.path: sys.path.append(f'../libs') +for folder in 'py-json', 'py-scripts': + if folder not in sys.path: + sys.path.append(f'../lanforge/lanforge-scripts/{folder}') +sys.path.append(f"../lanforge/lanforge-scripts/py-scripts/tip-cicd-sanity") + +sys.path.append(f'../libs') +sys.path.append(f'../libs/lanforge/') + +from LANforge.LFUtils import * + +if 'py-json' not in sys.path: + sys.path.append('../py-scripts') from apnos.apnos import APNOS from controller.controller import Controller from controller.controller import ProfileUtility @@ -24,6 +37,8 @@ from configuration import CONFIGURATION from configuration import FIRMWARE from testrails.testrail_api import APIClient from testrails.reporting import Reporting +import sta_connect2 +from sta_connect2 import StaConnect2 def pytest_addoption(parser): @@ -58,16 +73,10 @@ def pytest_addoption(parser): ) # this has to be the last argument # example: --access-points ECW5410 EA8300-EU - parser.addoption( - "--model", - # nargs="+", - default="ecw5410", - help="AP Model which is needed to test" - ) parser.addoption( "--testbed", # nargs="+", - default="lab-info", + default="basic-01", help="AP Model which is needed to test" ) parser.addoption( @@ -86,6 +95,8 @@ Test session base fixture @pytest.fixture(scope="session") def testbed(request): var = request.config.getoption("--testbed") + allure.attach(body=str(var), + name="Testbed Selected : ") yield var @@ -99,65 +110,87 @@ def should_upgrade_firmware(request): yield request.config.getoption("--force-upgrade") -""" -Instantiate Objects for Test session -""" - - @pytest.fixture(scope="session") -def instantiate_controller(request, testbed): - try: - sdk_client = Controller(controller_data=CONFIGURATION[testbed]["controller"]) +def radius_info(): + allure.attach(body=str(RADIUS_SERVER_DATA), name="Radius server Info: ") + yield RADIUS_SERVER_DATA - def teardown_session(): + +# Get Configuration data f +@pytest.fixture(scope="session") +def get_configuration(testbed): + allure.attach(body=str(testbed), name="Testbed Selected: ") + yield CONFIGURATION[testbed] + + +# APNOS Library +@pytest.fixture(scope="session") +def get_apnos(): + yield APNOS + + +# Controller Fixture +@pytest.fixture(scope="session") +def setup_controller(request, get_configuration): + try: + sdk_client = Controller(controller_data=get_configuration["controller"]) + allure.attach(body=str(get_configuration["controller"]), name="Controller Instantiated: ") + + def teardown_controller(): print("\nTest session Completed") + allure.attach(body=str(get_configuration["controller"]), name="Controller Teardown: ") sdk_client.disconnect_Controller() - request.addfinalizer(teardown_session) + request.addfinalizer(teardown_controller) except Exception as e: print(e) + allure.attach(body=str(e), name="Controller Instantiation Failed: ") sdk_client = False yield sdk_client @pytest.fixture(scope="session") -def instantiate_testrail(request): +def instantiate_firmware(controller_instance, instantiate_jFrog, get_configuration): + firmware_client_obj = [] + for access_point_info in get_configuration['access_point']: + firmware_client = FirmwareUtility(jfrog_credentials=instantiate_jFrog, sdk_client=controller_instance, + model=access_point_info["model"], + version=access_point_info["version"]) + firmware_client_obj.append(firmware_client) + yield firmware_client_obj + + +""" +Instantiate Reporting +""" + + +@pytest.fixture(scope="session") +def instantiate_reporting(request, testbed, get_latest_firmware): if request.config.getoption("--skip-testrail"): tr_client = Reporting() else: tr_client = APIClient(request.config.getini("tr_url"), request.config.getini("tr_user"), request.config.getini("tr_pass"), request.config.getini("tr_project_id")) + if request.config.getoption("--skip-testrail"): + tr_client.rid = "skip testrails" + else: + projId = tr_client.get_project_id(project_name=request.config.getini("tr_project_id")) + test_run_name = request.config.getini("tr_prefix") + testbed + "_" + str( + datetime.date.today()) + "_" + get_latest_firmware + tr_client.create_testrun(name=test_run_name, case_ids=list(TEST_CASES.values()), project_id=projId, + milestone_id=request.config.getini("milestone"), + description="Automated Nightly Sanity test run for new firmware build") + rid = tr_client.get_run_id(test_run_name=test_run_name) + tr_client.rid = rid yield tr_client -@pytest.fixture(scope="session") -def instantiate_firmware(instantiate_controller, instantiate_jFrog, testbed): - firmware_client = FirmwareUtility(jfrog_credentials=instantiate_jFrog, sdk_client=instantiate_controller, - model=CONFIGURATION[testbed]["access_point"][0]["model"], - version=CONFIGURATION[testbed]["access_point"][0]["version"]) - yield firmware_client - - @pytest.fixture(scope="session") def instantiate_jFrog(): yield FIRMWARE["JFROG"] -@pytest.fixture(scope="session") -def instantiate_project(request, instantiate_testrail, testbed, get_latest_firmware): - if request.config.getoption("--skip-testrail"): - rid = "skip testrails" - else: - projId = instantiate_testrail.get_project_id(project_name=request.config.getini("tr_project_id")) - test_run_name = request.config.getini("tr_prefix") + testbed + "_" + str( - datetime.date.today()) + "_" + get_latest_firmware - instantiate_testrail.create_testrun(name=test_run_name, case_ids=list(TEST_CASES.values()), project_id=projId, - milestone_id=request.config.getini("milestone"), - description="Automated Nightly Sanity test run for new firmware build") - rid = instantiate_testrail.get_run_id(test_run_name=test_run_name) - yield rid - - @pytest.fixture(scope="session") def check_lanforge_connectivity(testbed): # Check port @@ -225,7 +258,7 @@ def setup_profile_data(testbed): @pytest.fixture(scope="session") def get_security_flags(): - security = ["open", "wpa", "wpa2_personal", "wpa2_enterprise", "twog", "fiveg", "radius"] + security = ["open", "wpa", "wpa2_personal", "wpa2_enterprise", "wpa3_enterprise", "twog", "fiveg", "radius"] yield security @@ -245,6 +278,7 @@ def get_markers(request, get_security_flags): else: security_dict[i] = False # print(security_dict) + allure.attach(body=str(security_dict), name="Test Cases Requires: ") yield security_dict @@ -271,5 +305,5 @@ def check_ap_firmware_ssh(testbed): @pytest.fixture(scope="session") -def radius_info(): - yield RADIUS_SERVER_DATA +def client_connectivity(): + yield StaConnect2 diff --git a/tests/e2e/basic/client_connectivity_test/bridge/__init__.py b/tests/e2e/basic/client_connectivity_test/bridge/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/e2e/basic/client_connectivity_test/bridge/basic_security_modes/__init__.py b/tests/e2e/basic/client_connectivity_test/bridge/basic_security_modes/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/e2e/basic/client_connectivity_test/bridge/basic_security_modes/test__configuration_basic_modes.py b/tests/e2e/basic/client_connectivity_test/bridge/basic_security_modes/test__configuration_basic_modes.py new file mode 100644 index 000000000..d9b969a83 --- /dev/null +++ b/tests/e2e/basic/client_connectivity_test/bridge/basic_security_modes/test__configuration_basic_modes.py @@ -0,0 +1,91 @@ +import pytest +import allure + +pytestmark = [pytest.mark.client_connectivity, pytest.mark.bridge, pytest.mark.configuration, pytest.mark.basic] + +setup_params_general = { + "mode": "BRIDGE", + "ssid_modes": { + "open": [{"ssid_name": "ssid_open_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_open_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], + "wpa": [{"ssid_name": "ssid_wpa_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa2_personal": [ + {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}]}, + "rf": {}, + "radius": False +} + + +@allure.feature("BRIDGE MODE CLIENT CONNECTIVITY") +@pytest.mark.parametrize( + 'setup_client_connectivity', + [setup_params_general], + indirect=True, + scope="package" +) +@pytest.mark.usefixtures("setup_client_connectivity") +class TestBridgeModeConfiguration(object): + + @pytest.mark.open + @pytest.mark.twog + @allure.story('open 2.4 GHZ Band') + def test_open_ssid_2g_config(self, setup_client_connectivity): + allure.attach(str(setup_client_connectivity["open_2g"]), 'OPEN SSID 2.4 GHz Creation : ') + assert setup_client_connectivity["open_2g"] + + @pytest.mark.open + @pytest.mark.fiveg + @allure.story('open 5 GHZ Band') + def test_open_ssid_5g_config(self, setup_client_connectivity): + allure.attach(str(setup_client_connectivity["open_5g"]), 'OPEN SSID 5 GHz Creation : ') + assert setup_client_connectivity["open_5g"] + + @pytest.mark.wpa + @pytest.mark.twog + @allure.story('wpa 2.4 GHZ Band') + def test_wpa_ssid_2g_config(self, setup_client_connectivity): + print(setup_client_connectivity) + allure.attach(str(setup_client_connectivity["wpa_2g"]), 'WPA SSID 2.4 GHz Creation : ') + assert setup_client_connectivity["wpa_2g"] + + @pytest.mark.wpa + @pytest.mark.fiveg + @allure.story('wpa 5 GHZ Band') + def test_wpa_ssid_5g_config(self, setup_client_connectivity): + allure.attach(str(setup_client_connectivity["wpa_5g"]), 'WPA SSID 5 GHz Creation : ') + assert setup_client_connectivity["wpa_5g"] + + @pytest.mark.wpa2_personal + @pytest.mark.twog + @allure.story('wpa2_personal 2.4 GHZ Band') + def test_wpa2_personal_ssid_2g_config(self, setup_client_connectivity): + allure.attach(str(setup_client_connectivity["wpa2_personal_2g"]), 'WPA2 Personal SSID 2.4 GHz Creation : ') + assert setup_client_connectivity["wpa2_personal_2g"] + + @pytest.mark.wpa2_personal + @pytest.mark.fiveg + @allure.story('wpa2_personal 5 GHZ Band') + def test_wpa2_personal_ssid_5g_config(self, setup_client_connectivity): + allure.attach(str(setup_client_connectivity["wpa2_personal_5g"]), 'WPA2 Personal SSID 5 GHz Creation : ') + assert setup_client_connectivity["wpa2_personal_5g"] + + @allure.story('equipment AP Configuration') + def test_equipment_ap_profile_configuration(self, setup_client_connectivity): + allure.attach(str(setup_client_connectivity["equipment_ap"]), 'Equipment AP Profile Creation : ') + assert setup_client_connectivity["equipment_ap"] + + @allure.story('Config push from controller to AP') + def test_verify_vif_config(self, setup_client_connectivity): + allure.attach(str(setup_client_connectivity["vifc"]), 'Profile Push from Controller to AP : ') + assert setup_client_connectivity["vifc"] + + @allure.story('Config in VIF State') + def test_verify_vif_state(self, setup_client_connectivity): + allure.attach(str(setup_client_connectivity["vifs"]), 'VIF CONFIG AND VIF STATE ARE SAME : ') + assert setup_client_connectivity["vifs"] + + diff --git a/tests/e2e/basic/client_connectivity_test/bridge/basic_security_modes/test_basic_security.py b/tests/e2e/basic/client_connectivity_test/bridge/basic_security_modes/test_basic_security.py new file mode 100644 index 000000000..a0c86694f --- /dev/null +++ b/tests/e2e/basic/client_connectivity_test/bridge/basic_security_modes/test_basic_security.py @@ -0,0 +1,124 @@ +import time + +import pytest +import allure + +pytestmark = [pytest.mark.client_connectivity, pytest.mark.bridge, pytest.mark.basic] + +setup_params_general = { + "mode": "BRIDGE", + "ssid_modes": { + "open": [{"ssid_name": "ssid_open_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_open_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], + "wpa": [{"ssid_name": "ssid_wpa_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa2_personal": [ + {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}]}, + "rf": {}, + "radius": False +} + + +@allure.feature("BRIDGE MODE CLIENT CONNECTIVITY") +@pytest.mark.parametrize( + 'setup_client_connectivity', + [setup_params_general], + indirect=True, + scope="package" +) +@pytest.mark.usefixtures("setup_client_connectivity") +class TestBridgeModeConnectivity(object): + + @pytest.mark.open + @pytest.mark.twog + @allure.story('open 2.4 GHZ Band') + def test_open_ssid_2g(self): + ssid_data = setup_params_general["ssid_modes"]["open"][0] + print(ssid_data) + assert "setup_client_connectivity" + + @pytest.mark.open + @pytest.mark.fiveg + @allure.story('open 5 GHZ Band') + def test_open_ssid_5g(self): + ssid_data = setup_params_general["ssid_modes"]["open"][1] + print(ssid_data) + assert "setup_client_connectivity" + + @pytest.mark.wpa + @pytest.mark.twog + @allure.story('wpa 2.4 GHZ Band') + def test_wpa_ssid_2g(self, request, get_lanforge_data, instantiate_project, instantiate_testrail, + client_connectivity, test_cases): + profile_data = setup_params_general["ssid_modes"]["wpa"][0] + print(profile_data) + station_names = [] + for i in range(0, int(request.config.getini("num_stations"))): + station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) + print(profile_data, get_lanforge_data) + staConnect = client_connectivity(get_lanforge_data["lanforge_ip"], + int(get_lanforge_data["lanforge-port-number"]), + debug_=False) + staConnect.sta_mode = 0 + staConnect.upstream_resource = 1 + staConnect.upstream_port = get_lanforge_data["lanforge_bridge_port"] + staConnect.radio = get_lanforge_data["lanforge_2dot4g"] + staConnect.resource = 1 + staConnect.dut_ssid = profile_data["ssid_name"] + staConnect.dut_passwd = profile_data["security_key"] + staConnect.dut_security = "wpa" + staConnect.station_names = station_names + staConnect.sta_prefix = get_lanforge_data["lanforge_2dot4g_prefix"] + staConnect.runtime_secs = 10 + staConnect.bringup_time_sec = 60 + staConnect.cleanup_on_exit = True + # staConnect.cleanup() + staConnect.setup() + staConnect.start() + print("napping %f sec" % staConnect.runtime_secs) + time.sleep(staConnect.runtime_secs) + staConnect.stop() + staConnect.cleanup() + run_results = staConnect.get_result_list() + for result in run_results: + print("test result: " + result) + # result = 'pass' + print("Single Client Connectivity :", staConnect.passes) + if staConnect.passes(): + instantiate_testrail.update_testrail(case_id=test_cases["2g_wpa_bridge"], run_id=instantiate_project, + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + run_results)) + else: + instantiate_testrail.update_testrail(case_id=test_cases["2g_wpa_bridge"], run_id=instantiate_project, + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + run_results)) + assert staConnect.passes() + + @pytest.mark.wpa + @pytest.mark.fiveg + @allure.story('wpa 5 GHZ Band') + def test_wpa_ssid_5g(self): + ssid_data = setup_params_general["ssid_modes"]["wpa"][1] + print(ssid_data) + assert "setup_client_connectivity" + + @pytest.mark.wpa2_personal + @pytest.mark.twog + @allure.story('wpa2_personal 2.4 GHZ Band') + def test_wpa2_personal_ssid_2g(self): + ssid_data = setup_params_general["ssid_modes"]["wpa2_personal"][0] + print(ssid_data) + assert "setup_client_connectivity" + + @pytest.mark.wpa2_personal + @pytest.mark.fiveg + @allure.story('wpa2_personal 5 GHZ Band') + def test_wpa2_personal_ssid_5g(self): + ssid_data = setup_params_general["ssid_modes"]["wpa2_personal"][1] + print(ssid_data) + assert "setup_client_connectivity" diff --git a/tests/e2e/basic/client_connectivity_test/bridge/enterprise_security_modes/__init__.py b/tests/e2e/basic/client_connectivity_test/bridge/enterprise_security_modes/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/e2e/basic/client_connectivity_test/bridge/enterprise_security_modes/test_configuration_enterprise_modes.py b/tests/e2e/basic/client_connectivity_test/bridge/enterprise_security_modes/test_configuration_enterprise_modes.py new file mode 100644 index 000000000..4c9a03b6d --- /dev/null +++ b/tests/e2e/basic/client_connectivity_test/bridge/enterprise_security_modes/test_configuration_enterprise_modes.py @@ -0,0 +1,55 @@ +import pytest +import allure + +pytestmark = [pytest.mark.client_connectivity, pytest.mark.enterprise, pytest.mark.bridge, pytest.mark.configuration] + +setup_params_enterprise = { + "mode": "BRIDGE", + "ssid_modes": { + "wpa2_enterprise": [ + {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa3_enterprise": [ + {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, + + "rf": {}, + "radius": True +} + + +@pytest.mark.parametrize( + 'setup_client_connectivity', + [setup_params_enterprise], + indirect=True, + scope="package" +) +@pytest.mark.usefixtures("setup_client_connectivity") +class TestBridgeModeEnterprise(object): + + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + def test_wpa2_enterprise_2g(self): + # print(setup_client_connectivity) + assert "setup_client_connectivity" + + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + def test_wpa2_enterprise_5g(self): + assert "setup_client_connectivity" + + @pytest.mark.wpa3_enterprise + @pytest.mark.twog + def test_wpa3_enterprise_2g(self): + # print(setup_client_connectivity) + assert "setup_client_connectivity" + + @pytest.mark.wpa3_enterprise + @pytest.mark.fiveg + def test_wpa3_enterprise_5g(self): + assert "setup_client_connectivity" + + + + diff --git a/tests/e2e/basic/client_connectivity_test/bridge/enterprise_security_modes/test_enterprise_security.py b/tests/e2e/basic/client_connectivity_test/bridge/enterprise_security_modes/test_enterprise_security.py new file mode 100644 index 000000000..5c53e5772 --- /dev/null +++ b/tests/e2e/basic/client_connectivity_test/bridge/enterprise_security_modes/test_enterprise_security.py @@ -0,0 +1,55 @@ +import pytest +import allure + +pytestmark = [pytest.mark.client_connectivity, pytest.mark.enterprise, pytest.mark.bridge] + +setup_params_enterprise = { + "mode": "BRIDGE", + "ssid_modes": { + "wpa2_enterprise": [ + {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa3_enterprise": [ + {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, + + "rf": {}, + "radius": True +} + + +@pytest.mark.parametrize( + 'setup_client_connectivity', + [setup_params_enterprise], + indirect=True, + scope="package" +) +@pytest.mark.usefixtures("setup_client_connectivity") +class TestBridgeModeEnterprise(object): + + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + def test_wpa2_enterprise_2g(self,): + # print(setup_client_connectivity) + assert "setup_client_connectivity" + + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + def test_wpa2_enterprise_5g(self): + assert "setup_client_connectivity" + + @pytest.mark.wpa3_enterprise + @pytest.mark.twog + def test_wpa3_enterprise_2g(self): + # print(setup_client_connectivity) + assert "setup_client_connectivity" + + @pytest.mark.wpa3_enterprise + @pytest.mark.fiveg + def test_wpa3_enterprise_5g(self): + assert "setup_client_connectivity" + + + + diff --git a/tests/e2e/basic/client_connectivity_test/conftest.py b/tests/e2e/basic/client_connectivity_test/conftest.py new file mode 100644 index 000000000..a6e899ead --- /dev/null +++ b/tests/e2e/basic/client_connectivity_test/conftest.py @@ -0,0 +1,344 @@ +import time + +import pytest +import allure + + +@pytest.fixture(scope="session") +def setup_vlan(): + vlan_id = [100] + allure.attach(body=str(vlan_id), name="VLAN Created: ") + yield vlan_id[0] + + +@allure.feature("CLIENT CONNECTIVITY SETUP") +@pytest.fixture(scope="package") +def setup_client_connectivity(request, instantiate_controller, testbed, setup_vlan, get_equipment_id, + instantiate_profile, get_markers, + get_security_flags, get_configuration, radius_info, get_apnos): + instantiate_profile = instantiate_profile(sdk_client=instantiate_controller) + vlan_id, mode = 0, 0 + instantiate_profile.cleanup_objects() + parameter = dict(request.param) + test_cases = {} + profile_data = {} + if parameter['mode'] not in ["BRIDGE", "NAT", "VLAN"]: + print("Invalid Mode: ", parameter['mode']) + allure.attach(body=parameter['mode'], name="Invalid Mode: ") + yield test_cases + + if parameter['mode'] == "NAT": + mode = "NAT" + vlan_id = 1 + if parameter['mode'] == "BRIDGE": + mode = "BRIDGE" + vlan_id = 1 + if parameter['mode'] == "VLAN": + mode = "BRIDGE" + vlan_id = setup_vlan + + instantiate_profile.delete_profile_by_name(profile_name=testbed + "-Equipment-AP-" + parameter['mode']) + + profile_data["equipment_ap"] = {"profile_name": testbed + "-Equipment-AP-" + parameter['mode']} + profile_data["ssid"] = {} + for i in parameter["ssid_modes"]: + profile_data["ssid"][i] = [] + for j in range(len(parameter["ssid_modes"][i])): + profile_name = testbed + "-SSID-" + i + "-" + str(j) + "-" + parameter['mode'] + data = parameter["ssid_modes"][i][j] + data["profile_name"] = profile_name + if "mode" not in dict(data).keys(): + data["mode"] = mode + if "vlan" not in dict(data).keys(): + data["vlan"] = vlan_id + instantiate_profile.delete_profile_by_name(profile_name=profile_name) + profile_data["ssid"][i].append(data) + # print(profile_name) + # print(profile_data) + + instantiate_profile.delete_profile_by_name(profile_name=testbed + "-Automation-Radius-Profile-" + mode) + time.sleep(10) + """ + Setting up rf profile + """ + rf_profile_data = { + "name": "RF-Profile-" + testbed + "-" + parameter['mode'] + "-" + + get_configuration[testbed]['access_point'][0]['mode'] + } + + for i in parameter["rf"]: + rf_profile_data[i] = parameter['rf'][i] + # print(rf_profile_data) + + try: + instantiate_profile.delete_profile_by_name(profile_name=rf_profile_data['name']) + instantiate_profile.set_rf_profile(profile_data=rf_profile_data, + mode=get_configuration[testbed]['access_point'][0]['mode']) + allure.attach(body=str(rf_profile_data), + name="RF Profile Created : " + get_configuration[testbed]['access_point'][0]['mode']) + except Exception as e: + print(e) + allure.attach(body=str(e), name="Exception ") + + # Radius Profile Creation + if parameter["radius"]: + radius_info = radius_info + radius_info["name"] = testbed + "-Automation-Radius-Profile-" + testbed + instantiate_profile.delete_profile_by_name(profile_name=testbed + "-Automation-Radius-Profile-" + testbed) + try: + # pass + instantiate_profile.create_radius_profile(radius_info=radius_info) + allure.attach(body=str(radius_info), + name="Radius Profile Created") + test_cases['radius_profile'] = True + except Exception as e: + print(e) + test_cases['radius_profile'] = False + + # SSID Profile Creation + print(get_markers) + for mode in profile_data['ssid']: + if mode == "open": + for j in profile_data["ssid"][mode]: + # print(j) + if mode in get_markers.keys() and get_markers[mode]: + try: + if "twog" in get_markers.keys() and get_markers["twog"] and "is2dot4GHz" in list( + j["appliedRadios"]): + creates_profile = instantiate_profile.create_open_ssid_profile(profile_data=j) + test_cases["open_2g"] = True + allure.attach(body=str(creates_profile), + name="SSID Profile Created") + except Exception as e: + print(e) + test_cases["open_2g"] = False + allure.attach(body=str(e), + name="SSID Profile Creation Failed") + + try: + if "fiveg" in get_markers.keys() and get_markers["fiveg"] and "is5GHz" in list( + j["appliedRadios"]): + creates_profile = instantiate_profile.create_open_ssid_profile(profile_data=j) + test_cases["open_5g"] = True + allure.attach(body=str(creates_profile), + name="SSID Profile Created") + except Exception as e: + print(e) + test_cases["open_5g"] = False + allure.attach(body=str(e), + name="SSID Profile Creation Failed") + + if mode == "wpa": + for j in profile_data["ssid"][mode]: + # print(j) + if mode in get_markers.keys() and get_markers[mode]: + try: + if "twog" in get_markers.keys() and get_markers["twog"] and "is2dot4GHz" in list( + j["appliedRadios"]): + creates_profile = instantiate_profile.create_wpa_ssid_profile(profile_data=j) + test_cases["wpa_2g"] = True + allure.attach(body=str(creates_profile), + name="SSID Profile Created") + except Exception as e: + print(e) + test_cases["wpa_2g"] = False + allure.attach(body=str(e), + name="SSID Profile Creation Failed") + try: + if "fiveg" in get_markers.keys() and get_markers["fiveg"] and "is5GHz" in list( + j["appliedRadios"]): + creates_profile = instantiate_profile.create_wpa_ssid_profile(profile_data=j) + test_cases["wpa_5g"] = True + allure.attach(body=str(creates_profile), + name="SSID Profile Created") + except Exception as e: + print(e) + test_cases["wpa_5g"] = False + allure.attach(body=str(e), + name="SSID Profile Creation Failed") + if mode == "wpa2_personal": + for j in profile_data["ssid"][mode]: + # print(j) + if mode in get_markers.keys() and get_markers[mode]: + try: + if "twog" in get_markers.keys() and get_markers["twog"] and "is2dot4GHz" in list( + j["appliedRadios"]): + creates_profile = instantiate_profile.create_wpa2_personal_ssid_profile(profile_data=j) + test_cases["wpa2_personal_2g"] = True + allure.attach(body=str(creates_profile), + name="SSID Profile Created") + except Exception as e: + print(e) + test_cases["wpa2_personal_2g"] = False + allure.attach(body=str(e), + name="SSID Profile Creation Failed") + try: + if "fiveg" in get_markers.keys() and get_markers["fiveg"] and "is5GHz" in list( + j["appliedRadios"]): + creates_profile = instantiate_profile.create_wpa2_personal_ssid_profile(profile_data=j) + test_cases["wpa2_personal_5g"] = True + allure.attach(body=str(creates_profile), + name="SSID Profile Created") + except Exception as e: + print(e) + test_cases["wpa2_personal_5g"] = False + allure.attach(body=str(e), + name="SSID Profile Creation Failed") + + if mode == "wpa3_personal": + for j in profile_data["ssid"][mode]: + # print(j) + if mode in get_markers.keys() and get_markers[mode]: + try: + if "twog" in get_markers.keys() and get_markers["twog"] and "is2dot4GHz" in list( + j["appliedRadios"]): + creates_profile = instantiate_profile.create_wpa3_personal_ssid_profile(profile_data=j) + test_cases["wpa3_personal_2g"] = True + allure.attach(body=str(creates_profile), + name="SSID Profile Created") + except Exception as e: + print(e) + test_cases["wpa3_personal_2g"] = False + allure.attach(body=str(e), + name="SSID Profile Creation Failed") + try: + if "fiveg" in get_markers.keys() and get_markers["fiveg"] and "is5GHz" in list( + j["appliedRadios"]): + creates_profile = instantiate_profile.create_wpa3_personal_ssid_profile(profile_data=j) + test_cases["wpa3_personal_5g"] = True + allure.attach(body=str(creates_profile), + name="SSID Profile Created") + except Exception as e: + print(e) + test_cases["wpa3_personal_5g"] = False + allure.attach(body=str(e), + name="SSID Profile Creation Failed") + + if mode == "wpa2_enterprise": + for j in profile_data["ssid"][mode]: + # print(j) + if mode in get_markers.keys() and get_markers[mode]: + try: + if "twog" in get_markers.keys() and get_markers["twog"] and "is2dot4GHz" in list( + j["appliedRadios"]): + creates_profile = instantiate_profile.create_wpa2_enterprise_ssid_profile(profile_data=j) + test_cases["wpa2_enterprise_2g"] = True + allure.attach(body=str(creates_profile), + name="SSID Profile Created") + except Exception as e: + print(e) + test_cases["wpa2_enterprise_2g"] = False + allure.attach(body=str(e), + name="SSID Profile Creation Failed") + try: + if "fiveg" in get_markers.keys() and get_markers["fiveg"] and "is5GHz" in list( + j["appliedRadios"]): + creates_profile = instantiate_profile.create_wpa2_enterprise_ssid_profile(profile_data=j) + test_cases["wpa2_enterprise_5g"] = True + allure.attach(body=str(creates_profile), + name="SSID Profile Created") + except Exception as e: + print(e) + test_cases["wpa2_enterprise_5g"] = False + allure.attach(body=str(e), + name="SSID Profile Creation Failed") + + if mode == "wpa3_enterprise": + for j in profile_data["ssid"][mode]: + # print(j) + if mode in get_markers.keys() and get_markers[mode]: + try: + if "twog" in get_markers.keys() and get_markers["twog"] and "is2dot4GHz" in list( + j["appliedRadios"]): + creates_profile = instantiate_profile.create_wpa3_enterprise_ssid_profile(profile_data=j) + test_cases["wpa3_enterprise_2g"] = True + allure.attach(body=str(creates_profile), + name="SSID Profile Created") + except Exception as e: + print(e) + test_cases["wpa3_enterprise_2g"] = False + allure.attach(body=str(e), + name="SSID Profile Creation Failed") + try: + if "fiveg" in get_markers.keys() and get_markers["fiveg"] and "is5GHz" in list( + j["appliedRadios"]): + creates_profile = instantiate_profile.create_wpa3_enterprise_ssid_profile(profile_data=j) + test_cases["wpa3_enterprise_5g"] = True + allure.attach(body=str(creates_profile), + name="SSID Profile Created") + except Exception as e: + print(e) + test_cases["wpa3_enterprise_5g"] = False + allure.attach(body=str(e), + name="SSID Profile Creation Failed") + + # Equipment AP Profile Creation + try: + instantiate_profile.set_ap_profile(profile_data=profile_data['equipment_ap']) + test_cases["equipment_ap"] = True + allure.attach(body=str(profile_data['equipment_ap']), + name="Equipment AP Profile Created") + except Exception as e: + print(e) + test_cases["equipment_ap"] = False + allure.attach(body=str(e), + name="Equipment AP Profile Creation Failed") + + # Push the Equipment AP Profile to AP + try: + instantiate_profile.push_profile_old_method(equipment_id=get_equipment_id) + except Exception as e: + print(e) + print("failed to create AP Profile") + + ap_ssh = get_apnos(get_configuration[testbed]['access_point'][0], pwd="../libs/apnos/") + ssid_names = [] + for i in instantiate_profile.profile_creation_ids["ssid"]: + ssid_names.append(instantiate_profile.get_ssid_name_by_profile_id(profile_id=i)) + ssid_names.sort() + + # This loop will check the VIF Config with cloud profile + vif_config = [] + test_cases['vifc'] = False + for i in range(0, 18): + vif_config = list(ap_ssh.get_vif_config_ssids()) + vif_config.sort() + print(vif_config) + print(ssid_names) + if ssid_names == vif_config: + test_cases['vifc'] = True + break + time.sleep(10) + allure.attach(body=str("VIF Config: " + str(vif_config) + "\n" + "SSID Pushed from Controller: " + str(ssid_names)), + name="SSID Profiles in VIF Config and Controller: ") + ap_ssh = get_apnos(get_configuration[testbed]['access_point'][0], pwd="../libs/apnos/") + + # This loop will check the VIF Config with VIF State + test_cases['vifs'] = False + for i in range(0, 18): + vif_state = list(ap_ssh.get_vif_state_ssids()) + vif_state.sort() + vif_config = list(ap_ssh.get_vif_config_ssids()) + vif_config.sort() + print(vif_config) + print(vif_state) + if vif_state == vif_config: + test_cases['vifs'] = True + break + time.sleep(10) + allure.attach(body=str("VIF Config: " + str(vif_config) + "\n" + "VIF State: " + str(vif_state)), + name="SSID Profiles in VIF Config and VIF State: ") + print(test_cases) + + def teardown_session(): + print("\nRemoving Profiles") + instantiate_profile.delete_profile_by_name(profile_name=profile_data['equipment_ap']['profile_name']) + instantiate_profile.delete_profile(instantiate_profile.profile_creation_ids["ssid"]) + instantiate_profile.delete_profile(instantiate_profile.profile_creation_ids["radius"]) + instantiate_profile.delete_profile(instantiate_profile.profile_creation_ids["rf"]) + allure.attach(body=str(profile_data['equipment_ap']['profile_name'] + "\n"), + name="Tear Down in Profiles ") + time.sleep(20) + + request.addfinalizer(teardown_session) + yield test_cases diff --git a/tests/e2e/basic/client_connectivity_test/nat/__init__.py b/tests/e2e/basic/client_connectivity_test/nat/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/e2e/basic/client_connectivity_test/nat/basic_security_modes/__init__.py b/tests/e2e/basic/client_connectivity_test/nat/basic_security_modes/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/e2e/basic/client_connectivity_test/nat/basic_security_modes/test_basic_security.py b/tests/e2e/basic/client_connectivity_test/nat/basic_security_modes/test_basic_security.py new file mode 100644 index 000000000..5cb063d75 --- /dev/null +++ b/tests/e2e/basic/client_connectivity_test/nat/basic_security_modes/test_basic_security.py @@ -0,0 +1,78 @@ +import pytest +import allure + +pytestmark = [pytest.mark.client_connectivity, pytest.mark.nat] + +setup_params_general = { + "mode": "NAT", + "ssid_modes": { + "open": [{"ssid_name": "ssid_open_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_open_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], + "wpa": [{"ssid_name": "ssid_wpa_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa2_personal": [ + {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}]}, + "rf": {}, + "radius": False +} + + +@allure.feature("NAT MODE CLIENT CONNECTIVITY") +@pytest.mark.parametrize( + 'setup_client_connectivity', + [setup_params_general], + indirect=True, + scope="package" +) +@pytest.mark.usefixtures("setup_client_connectivity") +class TestNATModeConnectivity(object): + + + @pytest.mark.open + @pytest.mark.twog + @allure.story('open 2.4 GHZ Band') + def test_open_ssid_2g(self): + ssid_data = setup_params_general["ssid_modes"]["open"][0] + + assert "setup_client_connectivity" + + @pytest.mark.open + @pytest.mark.fiveg + @allure.story('open 5 GHZ Band') + def test_open_ssid_5g(self): + ssid_data = setup_params_general["ssid_modes"]["open"][1] + assert "setup_client_connectivity" + + @pytest.mark.wpa + @pytest.mark.twog + @allure.story('wpa 2.4 GHZ Band') + def test_wpa_ssid_2g(self): + ssid_data = setup_params_general["ssid_modes"]["wpa"][0] + # print(setup_client_connectivity) + assert "setup_client_connectivity" + + @pytest.mark.wpa + @pytest.mark.fiveg + @allure.story('wpa 5 GHZ Band') + def test_wpa_ssid_5g(self): + ssid_data = setup_params_general["ssid_modes"]["wpa"][1] + assert "setup_client_connectivity" + + @pytest.mark.wpa2_personal + @pytest.mark.twog + @allure.story('wpa2_personal 2.4 GHZ Band') + def test_wpa2_personal_ssid_2g(self): + ssid_data = setup_params_general["ssid_modes"]["wpa2_personal"][0] + # print(setup_client_connectivity) + assert "setup_client_connectivity" + + @pytest.mark.wpa2_personal + @pytest.mark.fiveg + @allure.story('wpa2_personal 5 GHZ Band') + def test_wpa2_personal_ssid_5g(self): + ssid_data = setup_params_general["ssid_modes"]["wpa2_personal"][1] + assert "setup_client_connectivity" + diff --git a/tests/e2e/basic/client_connectivity_test/nat/basic_security_modes/test_configuration_basic_modes.py b/tests/e2e/basic/client_connectivity_test/nat/basic_security_modes/test_configuration_basic_modes.py new file mode 100644 index 000000000..4d1afd556 --- /dev/null +++ b/tests/e2e/basic/client_connectivity_test/nat/basic_security_modes/test_configuration_basic_modes.py @@ -0,0 +1,78 @@ +import pytest +import allure + +pytestmark = [pytest.mark.client_connectivity, pytest.mark.nat, pytest.mark.configuration] + +setup_params_general = { + "mode": "NAT", + "ssid_modes": { + "open": [{"ssid_name": "ssid_open_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_open_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], + "wpa": [{"ssid_name": "ssid_wpa_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa2_personal": [ + {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}]}, + "rf": {}, + "radius": False +} + + +@allure.feature("NAT MODE CLIENT CONNECTIVITY") +@pytest.mark.parametrize( + 'setup_client_connectivity', + [setup_params_general], + indirect=True, + scope="package" +) +@pytest.mark.usefixtures("setup_client_connectivity") +class TestNATModeConnectivity(object): + + + @pytest.mark.open + @pytest.mark.twog + @allure.story('open 2.4 GHZ Band') + def test_open_ssid_2g(self, setup_client_connectivity): + ssid_data = setup_params_general["ssid_modes"]["open"][0] + allure.attach(str(setup_client_connectivity), 'Hello, World') + assert setup_client_connectivity + + @pytest.mark.open + @pytest.mark.fiveg + @allure.story('open 5 GHZ Band') + def test_open_ssid_5g(self, setup_client_connectivity): + ssid_data = setup_params_general["ssid_modes"]["open"][1] + assert setup_client_connectivity + + @pytest.mark.wpa + @pytest.mark.twog + @allure.story('wpa 2.4 GHZ Band') + def test_wpa_ssid_2g(self, setup_client_connectivity): + ssid_data = setup_params_general["ssid_modes"]["wpa"][0] + print(setup_client_connectivity) + assert setup_client_connectivity + + @pytest.mark.wpa + @pytest.mark.fiveg + @allure.story('wpa 5 GHZ Band') + def test_wpa_ssid_5g(self, setup_client_connectivity): + ssid_data = setup_params_general["ssid_modes"]["wpa"][1] + assert setup_client_connectivity + + @pytest.mark.wpa2_personal + @pytest.mark.twog + @allure.story('wpa2_personal 2.4 GHZ Band') + def test_wpa2_personal_ssid_2g(self, setup_client_connectivity): + ssid_data = setup_params_general["ssid_modes"]["wpa2_personal"][0] + print(setup_client_connectivity) + assert setup_client_connectivity + + @pytest.mark.wpa2_personal + @pytest.mark.fiveg + @allure.story('wpa2_personal 5 GHZ Band') + def test_wpa2_personal_ssid_5g(self, setup_client_connectivity): + ssid_data = setup_params_general["ssid_modes"]["wpa2_personal"][1] + assert setup_client_connectivity + diff --git a/tests/e2e/basic/client_connectivity_test/nat/enterprise_security_modes/__init__.py b/tests/e2e/basic/client_connectivity_test/nat/enterprise_security_modes/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/e2e/basic/client_connectivity_test/nat/enterprise_security_modes/test_configuration_enterprise_modes.py b/tests/e2e/basic/client_connectivity_test/nat/enterprise_security_modes/test_configuration_enterprise_modes.py new file mode 100644 index 000000000..4f7ed2f61 --- /dev/null +++ b/tests/e2e/basic/client_connectivity_test/nat/enterprise_security_modes/test_configuration_enterprise_modes.py @@ -0,0 +1,55 @@ +import pytest +import allure + +pytestmark = [pytest.mark.client_connectivity, pytest.mark.enterprise, pytest.mark.nat, pytest.mark.configuration] + +setup_params_enterprise = { + "mode": "NAT", + "ssid_modes": { + "wpa2_enterprise": [ + {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa3_enterprise": [ + {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, + + "rf": {}, + "radius": True +} + + +@pytest.mark.parametrize( + 'setup_client_connectivity', + [setup_params_enterprise], + indirect=True, + scope="package" +) +@pytest.mark.usefixtures("setup_client_connectivity") +class TestNATModeEnterprise(object): + + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + def test_wpa2_enterprise_2g(self): + # print(setup_client_connectivity) + assert "setup_client_connectivity" + + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + def test_wpa2_enterprise_5g(self): + assert "setup_client_connectivity" + + @pytest.mark.wpa3_enterprise + @pytest.mark.twog + def test_wpa3_enterprise_2g(self): + # print(setup_client_connectivity) + assert "setup_client_connectivity" + + @pytest.mark.wpa3_enterprise + @pytest.mark.fiveg + def test_wpa3_enterprise_5g(self): + assert "setup_client_connectivity" + + + + diff --git a/tests/e2e/basic/client_connectivity_test/nat/enterprise_security_modes/test_enterprise_security.py b/tests/e2e/basic/client_connectivity_test/nat/enterprise_security_modes/test_enterprise_security.py new file mode 100644 index 000000000..6cd94238d --- /dev/null +++ b/tests/e2e/basic/client_connectivity_test/nat/enterprise_security_modes/test_enterprise_security.py @@ -0,0 +1,55 @@ +import pytest +import allure + +pytestmark = [pytest.mark.client_connectivity, pytest.mark.enterprise, pytest.mark.nat] + +setup_params_enterprise = { + "mode": "NAT", + "ssid_modes": { + "wpa2_enterprise": [ + {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa3_enterprise": [ + {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, + + "rf": {}, + "radius": True +} + + +@pytest.mark.parametrize( + 'setup_client_connectivity', + [setup_params_enterprise], + indirect=True, + scope="package" +) +@pytest.mark.usefixtures("setup_client_connectivity") +class TestNATModeEnterprise(object): + + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + def test_wpa2_enterprise_2g(self,): + # print(setup_client_connectivity) + assert "setup_client_connectivity" + + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + def test_wpa2_enterprise_5g(self): + assert "setup_client_connectivity" + + @pytest.mark.wpa3_enterprise + @pytest.mark.twog + def test_wpa3_enterprise_2g(self): + # print(setup_client_connectivity) + assert "setup_client_connectivity" + + @pytest.mark.wpa3_enterprise + @pytest.mark.fiveg + def test_wpa3_enterprise_5g(self): + assert "setup_client_connectivity" + + + + diff --git a/tests/e2e/basic/client_connectivity_test/test_bridge_mode.py b/tests/e2e/basic/client_connectivity_test/test_bridge_mode.py deleted file mode 100644 index 99331b7fa..000000000 --- a/tests/e2e/basic/client_connectivity_test/test_bridge_mode.py +++ /dev/null @@ -1,379 +0,0 @@ -""" - Test Case Module: Client Connectivity Test - Mode: BRIDGE - -""" - -import pytest - -pytestmark = [pytest.mark.client_connectivity_test, pytest.mark.bridge] - -import sys - -for folder in 'py-json', 'py-scripts': - if folder not in sys.path: - sys.path.append(f'../lanforge/lanforge-scripts/{folder}') - -sys.path.append(f"../lanforge/lanforge-scripts/py-scripts/tip-cicd-sanity") - -sys.path.append(f'../libs') -sys.path.append(f'../libs/lanforge/') - -from LANforge.LFUtils import * - -if 'py-json' not in sys.path: - sys.path.append('../py-scripts') - -import sta_connect2 -from sta_connect2 import StaConnect2 -import eap_connect -from eap_connect import EAPConnect -import time - - -@pytest.mark.sanity -@pytest.mark.client_connectivity -@pytest.mark.wifi5 -@pytest.mark.wifi6 -@pytest.mark.parametrize( - 'setup_profiles, create_profiles', - [(["BRIDGE"], ["BRIDGE"])], - indirect=True, - scope="class" -) -@pytest.mark.usefixtures("setup_profiles") -@pytest.mark.usefixtures("create_profiles") -class TestBridgeModeClientConnectivity(object): - - @pytest.mark.wpa - @pytest.mark.twog - def test_client_wpa_2g(self, request, get_lanforge_data, setup_profile_data, instantiate_testrail, - instantiate_project, test_cases): - profile_data = setup_profile_data["BRIDGE"]["WPA"]["2G"] - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) - print(profile_data, get_lanforge_data) - staConnect = StaConnect2(get_lanforge_data["lanforge_ip"], int(get_lanforge_data["lanforge-port-number"]), - debug_=False) - staConnect.sta_mode = 0 - staConnect.upstream_resource = 1 - staConnect.upstream_port = get_lanforge_data["lanforge_bridge_port"] - staConnect.radio = get_lanforge_data["lanforge_2dot4g"] - staConnect.resource = 1 - staConnect.dut_ssid = profile_data["ssid_name"] - staConnect.dut_passwd = profile_data["security_key"] - staConnect.dut_security = "wpa" - staConnect.station_names = station_names - staConnect.sta_prefix = get_lanforge_data["lanforge_2dot4g_prefix"] - staConnect.runtime_secs = 10 - staConnect.bringup_time_sec = 60 - staConnect.cleanup_on_exit = True - # staConnect.cleanup() - staConnect.setup() - staConnect.start() - print("napping %f sec" % staConnect.runtime_secs) - time.sleep(staConnect.runtime_secs) - staConnect.stop() - staConnect.cleanup() - run_results = staConnect.get_result_list() - for result in run_results: - print("test result: " + result) - # result = 'pass' - print("Single Client Connectivity :", staConnect.passes) - if staConnect.passes(): - instantiate_testrail.update_testrail(case_id=test_cases["2g_wpa_bridge"], run_id=instantiate_project, - status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str(run_results)) - else: - instantiate_testrail.update_testrail(case_id=test_cases["2g_wpa_bridge"], run_id=instantiate_project, - status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str(run_results)) - assert staConnect.passes() - # C2420 - - @pytest.mark.wpa - @pytest.mark.fiveg - def test_client_wpa_5g(self, request, get_lanforge_data, setup_profile_data, instantiate_project, - instantiate_testrail, test_cases): - profile_data = setup_profile_data["BRIDGE"]["WPA"]["5G"] - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) - staConnect = StaConnect2(get_lanforge_data["lanforge_ip"], int(get_lanforge_data["lanforge-port-number"]), - debug_=False) - staConnect.sta_mode = 0 - staConnect.upstream_resource = 1 - staConnect.upstream_port = get_lanforge_data["lanforge_bridge_port"] - staConnect.radio = get_lanforge_data["lanforge_5g"] - staConnect.resource = 1 - staConnect.dut_ssid = profile_data["ssid_name"] - staConnect.dut_passwd = profile_data["security_key"] - staConnect.dut_security = "wpa" - staConnect.station_names = station_names - staConnect.sta_prefix = get_lanforge_data["lanforge_5g_prefix"] - staConnect.runtime_secs = 10 - staConnect.bringup_time_sec = 60 - staConnect.cleanup_on_exit = True - # staConnect.cleanup() - staConnect.setup() - staConnect.start() - print("napping %f sec" % staConnect.runtime_secs) - time.sleep(staConnect.runtime_secs) - staConnect.stop() - staConnect.cleanup() - run_results = staConnect.get_result_list() - for result in run_results: - print("test result: " + result) - # result = 'pass' - print("Single Client Connectivity :", staConnect.passes) - if staConnect.passes(): - instantiate_testrail.update_testrail(case_id=test_cases["5g_wpa_bridge"], run_id=instantiate_project, - status_id=1, - msg='5G WPA Client Connectivity Passed successfully - bridge mode' + str(run_results)) - else: - instantiate_testrail.update_testrail(case_id=test_cases["5g_wpa_bridge"], run_id=instantiate_project, - status_id=5, - msg='5G WPA Client Connectivity Failed - bridge mode' + str(run_results)) - assert staConnect.passes() - # C2419 - - @pytest.mark.wpa2_personal - @pytest.mark.twog - def test_client_wpa2_personal_2g(self, request, get_lanforge_data, setup_profile_data, instantiate_project, - instantiate_testrail, test_cases): - profile_data = setup_profile_data["BRIDGE"]["WPA2_P"]["2G"] - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) - staConnect = StaConnect2(get_lanforge_data["lanforge_ip"], int(get_lanforge_data["lanforge-port-number"]), - debug_=False) - staConnect.sta_mode = 0 - staConnect.upstream_resource = 1 - staConnect.upstream_port = get_lanforge_data["lanforge_bridge_port"] - staConnect.radio = get_lanforge_data["lanforge_2dot4g"] - staConnect.resource = 1 - staConnect.dut_ssid = profile_data["ssid_name"] - staConnect.dut_passwd = profile_data["security_key"] - staConnect.dut_security = "wpa2" - staConnect.station_names = station_names - staConnect.sta_prefix = get_lanforge_data["lanforge_2dot4g_prefix"] - staConnect.runtime_secs = 10 - staConnect.bringup_time_sec = 60 - staConnect.cleanup_on_exit = True - # staConnect.cleanup() - staConnect.setup() - staConnect.start() - print("napping %f sec" % staConnect.runtime_secs) - time.sleep(staConnect.runtime_secs) - staConnect.stop() - staConnect.cleanup() - run_results = staConnect.get_result_list() - for result in run_results: - print("test result: " + result) - # result = 'pass' - print("Single Client Connectivity :", staConnect.passes) - if staConnect.passes(): - instantiate_testrail.update_testrail(case_id=test_cases["2g_wpa2_bridge"], run_id=instantiate_project, - status_id=1, - msg='2G WPA2 Client Connectivity Passed successfully - bridge mode' + str(run_results)) - else: - instantiate_testrail.update_testrail(case_id=test_cases["2g_wpa2_bridge"], run_id=instantiate_project, - status_id=5, - msg='2G WPA2 Client Connectivity Failed - bridge mode' + str(run_results)) - assert staConnect.passes() - # C2237 - - @pytest.mark.wpa2_personal - @pytest.mark.fiveg - def test_client_wpa2_personal_5g(self, request, get_lanforge_data, setup_profile_data, instantiate_project, - instantiate_testrail, test_cases): - profile_data = setup_profile_data["BRIDGE"]["WPA2_P"]["5G"] - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) - staConnect = StaConnect2(get_lanforge_data["lanforge_ip"], int(get_lanforge_data["lanforge-port-number"]), - debug_=False) - staConnect.sta_mode = 0 - staConnect.upstream_resource = 1 - staConnect.upstream_port = get_lanforge_data["lanforge_bridge_port"] - staConnect.radio = get_lanforge_data["lanforge_5g"] - staConnect.resource = 1 - staConnect.dut_ssid = profile_data["ssid_name"] - staConnect.dut_passwd = profile_data["security_key"] - staConnect.dut_security = "wpa2" - staConnect.station_names = station_names - staConnect.sta_prefix = get_lanforge_data["lanforge_5g_prefix"] - staConnect.runtime_secs = 10 - staConnect.bringup_time_sec = 60 - staConnect.cleanup_on_exit = True - # staConnect.cleanup() - staConnect.setup() - staConnect.start() - print("napping %f sec" % staConnect.runtime_secs) - time.sleep(staConnect.runtime_secs) - staConnect.stop() - staConnect.cleanup() - run_results = staConnect.get_result_list() - for result in run_results: - print("test result: " + result) - # result = 'pass' - print("Single Client Connectivity :", staConnect.passes) - if staConnect.passes(): - instantiate_testrail.update_testrail(case_id=test_cases["5g_wpa2_bridge"], run_id=instantiate_project, - status_id=1, - msg='5G WPA2 Client Connectivity Passed successfully - bridge mode' + str(run_results)) - else: - instantiate_testrail.update_testrail(case_id=test_cases["5g_wpa2_bridge"], run_id=instantiate_project, - status_id=5, - msg='5G WPA2 Client Connectivity Failed - bridge mode' + str(run_results)) - assert staConnect.passes() - # C2236 - - @pytest.mark.wpa2_enterprise - @pytest.mark.twog - @pytest.mark.radius - def test_client_wpa2_enterprise_2g(self, request, get_lanforge_data, setup_profile_data, instantiate_project, - instantiate_testrail, radius_info, test_cases): - profile_data = setup_profile_data["BRIDGE"]["WPA2_E"]["2G"] - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) - eap_connect = EAPConnect(get_lanforge_data["lanforge_ip"], get_lanforge_data["lanforge-port-number"]) - eap_connect.upstream_resource = 1 - eap_connect.upstream_port = get_lanforge_data["lanforge_bridge_port"] - eap_connect.security = "wpa2" - eap_connect.sta_list = station_names - eap_connect.station_names = station_names - eap_connect.sta_prefix = get_lanforge_data["lanforge_2dot4g_prefix"] - eap_connect.ssid = profile_data["ssid_name"] - eap_connect.radio = get_lanforge_data["lanforge_2dot4g"] - eap_connect.eap = "TTLS" - eap_connect.identity = radius_info["user"] - eap_connect.ttls_passwd = radius_info["password"] - eap_connect.runtime_secs = 10 - eap_connect.setup() - eap_connect.start() - print("napping %f sec" % eap_connect.runtime_secs) - time.sleep(eap_connect.runtime_secs) - eap_connect.stop() - try: - eap_connect.cleanup() - eap_connect.cleanup() - except: - pass - run_results = eap_connect.get_result_list() - for result in run_results: - print("test result: " + result) - # result = 'pass' - print("Single Client Connectivity :", eap_connect.passes) - if eap_connect.passes(): - instantiate_testrail.update_testrail(case_id=test_cases["2g_eap_bridge"], run_id=instantiate_project, - status_id=1, - msg='5G WPA2 ENTERPRISE Client Connectivity Passed successfully - ' - 'bridge mode' + str(run_results)) - else: - instantiate_testrail.update_testrail(case_id=test_cases["2g_eap_bridge"], run_id=instantiate_project, - status_id=5, - msg='5G WPA2 ENTERPRISE Client Connectivity Failed - bridge mode' + str(run_results)) - assert eap_connect.passes() - # C5214 - - @pytest.mark.wpa2_enterprise - @pytest.mark.fiveg - @pytest.mark.radius - def test_client_wpa2_enterprise_5g(self, request, get_lanforge_data, setup_profile_data, instantiate_project, - instantiate_testrail, radius_info, test_cases): - profile_data = setup_profile_data["BRIDGE"]["WPA2_E"]["5G"] - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) - eap_connect = EAPConnect(get_lanforge_data["lanforge_ip"], get_lanforge_data["lanforge-port-number"]) - eap_connect.upstream_resource = 1 - eap_connect.upstream_port = get_lanforge_data["lanforge_bridge_port"] - eap_connect.security = "wpa2" - eap_connect.sta_list = station_names - eap_connect.station_names = station_names - eap_connect.sta_prefix = get_lanforge_data["lanforge_5g_prefix"] - eap_connect.ssid = profile_data["ssid_name"] - eap_connect.radio = get_lanforge_data["lanforge_5g"] - eap_connect.eap = "TTLS" - eap_connect.identity = radius_info["user"] - eap_connect.ttls_passwd = radius_info["password"] - eap_connect.runtime_secs = 10 - eap_connect.setup() - eap_connect.start() - print("napping %f sec" % eap_connect.runtime_secs) - time.sleep(eap_connect.runtime_secs) - eap_connect.stop() - try: - eap_connect.cleanup() - eap_connect.cleanup() - except: - pass - run_results = eap_connect.get_result_list() - for result in run_results: - print("test result: " + result) - # result = 'pass' - print("Single Client Connectivity :", eap_connect.passes) - if eap_connect.passes(): - instantiate_testrail.update_testrail(case_id=test_cases["5g_eap_bridge"], run_id=instantiate_project, - status_id=1, - msg='5G WPA2 ENTERPRISE Client Connectivity Passed successfully - ' - 'bridge mode' + str(run_results)) - else: - instantiate_testrail.update_testrail(case_id=test_cases["5g_eap_bridge"], run_id=instantiate_project, - status_id=5, - msg='5G WPA2 ENTERPRISE Client Connectivity Failed - bridge mode' + str(run_results)) - assert eap_connect.passes() - - @pytest.mark.modify_ssid - @pytest.mark.parametrize( - 'update_ssid', - (["BRIDGE, WPA, 5G, Sanity-updated-5G-WPA-BRIDGE"]), - indirect=True - ) - def test_modify_ssid(self, request, update_ssid, get_lanforge_data, setup_profile_data, instantiate_testrail, - instantiate_project, test_cases, instantiate_controller): - profile_data = setup_profile_data["BRIDGE"]["WPA"]["5G"] - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) - staConnect = StaConnect2(get_lanforge_data["lanforge_ip"], int(get_lanforge_data["lanforge-port-number"]), - debug_=False) - staConnect.sta_mode = 0 - staConnect.upstream_resource = 1 - staConnect.upstream_port = get_lanforge_data["lanforge_bridge_port"] - staConnect.radio = get_lanforge_data["lanforge_5g"] - staConnect.resource = 1 - staConnect.dut_ssid = profile_data["ssid_name"] - staConnect.dut_passwd = profile_data["security_key"] - staConnect.dut_security = "wpa" - staConnect.station_names = station_names - staConnect.sta_prefix = get_lanforge_data["lanforge_5g_prefix"] - staConnect.runtime_secs = 10 - staConnect.bringup_time_sec = 60 - staConnect.cleanup_on_exit = True - # staConnect.cleanup() - staConnect.setup() - staConnect.start() - print("napping %f sec" % staConnect.runtime_secs) - time.sleep(staConnect.runtime_secs) - staConnect.stop() - staConnect.cleanup() - run_results = staConnect.get_result_list() - for result in run_results: - print("test result: " + result) - # result = 'pass' - print("Single Client Connectivity :", staConnect.passes) - if staConnect.passes(): - instantiate_testrail.update_testrail(case_id=test_cases["bridge_ssid_update"], run_id=instantiate_project, - status_id=1, - msg='5G WPA Client Connectivity Passed successfully - bridge mode ' - 'updated ssid' + str(run_results)) - else: - instantiate_testrail.update_testrail(case_id=test_cases["bridge_ssid_update"], run_id=instantiate_project, - status_id=5, - msg='5G WPA Client Connectivity Failed - bridge mode updated ssid' + str(run_results)) - instantiate_controller.refresh_instance() - assert staConnect.passes() diff --git a/tests/e2e/basic/client_connectivity_test/test_nat_mode.py b/tests/e2e/basic/client_connectivity_test/test_nat_mode.py deleted file mode 100644 index 5106f26ef..000000000 --- a/tests/e2e/basic/client_connectivity_test/test_nat_mode.py +++ /dev/null @@ -1,378 +0,0 @@ -""" - Test Case Module: Client Connectivity Test - Mode: NAT - -""" - -import pytest -import sys - -pytestmark = [pytest.mark.client_connectivity_test, pytest.mark.nat] - -for folder in 'py-json', 'py-scripts': - if folder not in sys.path: - sys.path.append(f'../lanforge/lanforge-scripts/{folder}') - -sys.path.append(f"../lanforge/lanforge-scripts/py-scripts/tip-cicd-sanity") - -sys.path.append(f'../libs') -sys.path.append(f'../libs/lanforge/') - -from LANforge.LFUtils import * - -if 'py-json' not in sys.path: - sys.path.append('../py-scripts') - -from sta_connect2 import StaConnect2 -from eap_connect import EAPConnect -import time - - -# - -@pytest.mark.sanity -@pytest.mark.nat -@pytest.mark.wifi5 -@pytest.mark.wifi6 -@pytest.mark.parametrize( - 'setup_profiles, create_profiles', - [(["NAT"], ["NAT"])], - indirect=True, - scope="class" -) -@pytest.mark.usefixtures("setup_profiles") -@pytest.mark.usefixtures("create_profiles") -class TestNatModeClientConnectivity(object): - - @pytest.mark.wpa - @pytest.mark.twog - def test_client_wpa_2g(self, request, get_lanforge_data, setup_profile_data, instantiate_testrail, - instantiate_project, test_cases): - profile_data = setup_profile_data["NAT"]["WPA"]["2G"] - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) - print(profile_data, get_lanforge_data) - staConnect = StaConnect2(get_lanforge_data["lanforge_ip"], int(get_lanforge_data["lanforge-port-number"]), - debug_=False) - staConnect.sta_mode = 0 - staConnect.upstream_resource = 1 - staConnect.upstream_port = get_lanforge_data["lanforge_bridge_port"] - staConnect.radio = get_lanforge_data["lanforge_2dot4g"] - staConnect.resource = 1 - staConnect.dut_ssid = profile_data["ssid_name"] - staConnect.dut_passwd = profile_data["security_key"] - staConnect.dut_security = "wpa" - staConnect.station_names = station_names - staConnect.sta_prefix = get_lanforge_data["lanforge_2dot4g_prefix"] - staConnect.runtime_secs = 10 - staConnect.bringup_time_sec = 60 - staConnect.cleanup_on_exit = True - # staConnect.cleanup() - staConnect.setup() - staConnect.start() - print("napping %f sec" % staConnect.runtime_secs) - time.sleep(staConnect.runtime_secs) - staConnect.stop() - staConnect.cleanup() - run_results = staConnect.get_result_list() - for result in run_results: - print("test result: " + result) - # result = 'pass' - print("Single Client Connectivity :", staConnect.passes) - if staConnect.passes(): - instantiate_testrail.update_testrail(case_id=test_cases["2g_wpa_nat"], run_id=instantiate_project, - status_id=1, - msg='2G WPA Client Connectivity Passed successfully - nat mode' + str(run_results)) - else: - instantiate_testrail.update_testrail(case_id=test_cases["2g_wpa_nat"], run_id=instantiate_project, - status_id=5, - msg='2G WPA Client Connectivity Failed - nat mode' + str(run_results)) - assert staConnect.passes() - # C2420 - - @pytest.mark.wpa - @pytest.mark.fiveg - def test_client_wpa_5g(self, request, get_lanforge_data, setup_profile_data, instantiate_project, - instantiate_testrail, test_cases): - profile_data = setup_profile_data["NAT"]["WPA"]["5G"] - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) - staConnect = StaConnect2(get_lanforge_data["lanforge_ip"], int(get_lanforge_data["lanforge-port-number"]), - debug_=False) - staConnect.sta_mode = 0 - staConnect.upstream_resource = 1 - staConnect.upstream_port = get_lanforge_data["lanforge_bridge_port"] - staConnect.radio = get_lanforge_data["lanforge_5g"] - staConnect.resource = 1 - staConnect.dut_ssid = profile_data["ssid_name"] - staConnect.dut_passwd = profile_data["security_key"] - staConnect.dut_security = "wpa" - staConnect.station_names = station_names - staConnect.sta_prefix = get_lanforge_data["lanforge_5g_prefix"] - staConnect.runtime_secs = 10 - staConnect.bringup_time_sec = 60 - staConnect.cleanup_on_exit = True - # staConnect.cleanup() - staConnect.setup() - staConnect.start() - print("napping %f sec" % staConnect.runtime_secs) - time.sleep(staConnect.runtime_secs) - staConnect.stop() - staConnect.cleanup() - run_results = staConnect.get_result_list() - for result in run_results: - print("test result: " + result) - # result = 'pass' - print("Single Client Connectivity :", staConnect.passes) - if staConnect.passes(): - instantiate_testrail.update_testrail(case_id=test_cases["5g_wpa_nat"], run_id=instantiate_project, - status_id=1, - msg='5G WPA Client Connectivity Passed successfully - nat mode' + str(run_results)) - else: - instantiate_testrail.update_testrail(case_id=test_cases["5g_wpa_nat"], run_id=instantiate_project, - status_id=5, - msg='5G WPA Client Connectivity Failed - nat mode' + str(run_results)) - assert staConnect.passes() - # C2419 - - @pytest.mark.wpa2_personal - @pytest.mark.twog - def test_client_wpa2_personal_2g(self, request, get_lanforge_data, setup_profile_data, instantiate_project, - instantiate_testrail, test_cases): - profile_data = setup_profile_data["NAT"]["WPA2_P"]["2G"] - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) - staConnect = StaConnect2(get_lanforge_data["lanforge_ip"], int(get_lanforge_data["lanforge-port-number"]), - debug_=False) - staConnect.sta_mode = 0 - staConnect.upstream_resource = 1 - staConnect.upstream_port = get_lanforge_data["lanforge_bridge_port"] - staConnect.radio = get_lanforge_data["lanforge_2dot4g"] - staConnect.resource = 1 - staConnect.dut_ssid = profile_data["ssid_name"] - staConnect.dut_passwd = profile_data["security_key"] - staConnect.dut_security = "wpa2" - staConnect.station_names = station_names - staConnect.sta_prefix = get_lanforge_data["lanforge_2dot4g_prefix"] - staConnect.runtime_secs = 10 - staConnect.bringup_time_sec = 60 - staConnect.cleanup_on_exit = True - # staConnect.cleanup() - staConnect.setup() - staConnect.start() - print("napping %f sec" % staConnect.runtime_secs) - time.sleep(staConnect.runtime_secs) - staConnect.stop() - staConnect.cleanup() - run_results = staConnect.get_result_list() - for result in run_results: - print("test result: " + result) - # result = 'pass' - print("Single Client Connectivity :", staConnect.passes) - if staConnect.passes(): - instantiate_testrail.update_testrail(case_id=test_cases["2g_wpa2_nat"], run_id=instantiate_project, - status_id=1, - msg='2G WPA2 Client Connectivity Passed successfully - nat mode' + str(run_results)) - else: - instantiate_testrail.update_testrail(case_id=test_cases["2g_wpa2_nat"], run_id=instantiate_project, - status_id=5, - msg='2G WPA2 Client Connectivity Failed - nat mode' + str(run_results)) - assert staConnect.passes() - # C2237 - - @pytest.mark.wpa2_personal - @pytest.mark.fiveg - def test_client_wpa2_personal_5g(self, request, get_lanforge_data, setup_profile_data, instantiate_project, - instantiate_testrail, test_cases): - profile_data = setup_profile_data["NAT"]["WPA2_P"]["5G"] - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) - staConnect = StaConnect2(get_lanforge_data["lanforge_ip"], int(get_lanforge_data["lanforge-port-number"]), - debug_=False) - staConnect.sta_mode = 0 - staConnect.upstream_resource = 1 - staConnect.upstream_port = get_lanforge_data["lanforge_bridge_port"] - staConnect.radio = get_lanforge_data["lanforge_5g"] - staConnect.resource = 1 - staConnect.dut_ssid = profile_data["ssid_name"] - staConnect.dut_passwd = profile_data["security_key"] - staConnect.dut_security = "wpa2" - staConnect.station_names = station_names - staConnect.sta_prefix = get_lanforge_data["lanforge_5g_prefix"] - staConnect.runtime_secs = 10 - staConnect.bringup_time_sec = 60 - staConnect.cleanup_on_exit = True - # staConnect.cleanup() - staConnect.setup() - staConnect.start() - print("napping %f sec" % staConnect.runtime_secs) - time.sleep(staConnect.runtime_secs) - staConnect.stop() - staConnect.cleanup() - run_results = staConnect.get_result_list() - for result in run_results: - print("test result: " + result) - # result = 'pass' - print("Single Client Connectivity :", staConnect.passes) - if staConnect.passes(): - instantiate_testrail.update_testrail(case_id=test_cases["5g_wpa2_nat"], run_id=instantiate_project, - status_id=1, - msg='5G WPA2 Client Connectivity Passed successfully - nat mode' + str(run_results)) - else: - instantiate_testrail.update_testrail(case_id=test_cases["5g_wpa2_nat"], run_id=instantiate_project, - status_id=5, - msg='5G WPA2 Client Connectivity Failed - nat mode' + str(run_results)) - assert staConnect.passes() - # C2236 - - @pytest.mark.wpa2_enterprise - @pytest.mark.twog - @pytest.mark.radius - def test_client_wpa2_enterprise_2g(self, request, get_lanforge_data, setup_profile_data, instantiate_project, - instantiate_testrail, radius_info, test_cases): - profile_data = setup_profile_data["NAT"]["WPA2_E"]["2G"] - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) - eap_connect = EAPConnect(get_lanforge_data["lanforge_ip"], get_lanforge_data["lanforge-port-number"]) - eap_connect.upstream_resource = 1 - eap_connect.upstream_port = get_lanforge_data["lanforge_bridge_port"] - eap_connect.security = "wpa2" - eap_connect.sta_list = station_names - eap_connect.station_names = station_names - eap_connect.sta_prefix = get_lanforge_data["lanforge_2dot4g_prefix"] - eap_connect.ssid = profile_data["ssid_name"] - eap_connect.radio = get_lanforge_data["lanforge_2dot4g"] - eap_connect.eap = "TTLS" - eap_connect.identity = radius_info["user"] - eap_connect.ttls_passwd = radius_info["password"] - eap_connect.runtime_secs = 10 - eap_connect.setup() - eap_connect.start() - print("napping %f sec" % eap_connect.runtime_secs) - time.sleep(eap_connect.runtime_secs) - eap_connect.stop() - try: - eap_connect.cleanup() - eap_connect.cleanup() - except: - pass - run_results = eap_connect.get_result_list() - for result in run_results: - print("test result: " + result) - # result = 'pass' - print("Single Client Connectivity :", eap_connect.passes) - if eap_connect.passes(): - instantiate_testrail.update_testrail(case_id=test_cases["2g_eap_nat"], run_id=instantiate_project, - status_id=1, - msg='5G WPA2 ENTERPRISE Client Connectivity Passed successfully - ' - 'nat mode' + str(run_results)) - else: - instantiate_testrail.update_testrail(case_id=test_cases["2g_eap_nat"], run_id=instantiate_project, - status_id=5, - msg='5G WPA2 ENTERPRISE Client Connectivity Failed - nat mode' + str(run_results)) - assert eap_connect.passes() - # C5214 - - @pytest.mark.wpa2_enterprise - @pytest.mark.fiveg - @pytest.mark.radius - def test_client_wpa2_enterprise_5g(self, request, get_lanforge_data, setup_profile_data, instantiate_project, - instantiate_testrail, radius_info, test_cases): - profile_data = setup_profile_data["NAT"]["WPA2_E"]["5G"] - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) - eap_connect = EAPConnect(get_lanforge_data["lanforge_ip"], get_lanforge_data["lanforge-port-number"]) - eap_connect.upstream_resource = 1 - eap_connect.upstream_port = get_lanforge_data["lanforge_bridge_port"] - eap_connect.security = "wpa2" - eap_connect.sta_list = station_names - eap_connect.station_names = station_names - eap_connect.sta_prefix = get_lanforge_data["lanforge_5g_prefix"] - eap_connect.ssid = profile_data["ssid_name"] - eap_connect.radio = get_lanforge_data["lanforge_5g"] - eap_connect.eap = "TTLS" - eap_connect.identity = radius_info["user"] - eap_connect.ttls_passwd = radius_info["password"] - eap_connect.runtime_secs = 10 - eap_connect.setup() - eap_connect.start() - print("napping %f sec" % eap_connect.runtime_secs) - time.sleep(eap_connect.runtime_secs) - eap_connect.stop() - try: - eap_connect.cleanup() - eap_connect.cleanup() - except: - pass - run_results = eap_connect.get_result_list() - for result in run_results: - print("test result: " + result) - # result = 'pass' - print("Single Client Connectivity :", eap_connect.passes) - if eap_connect.passes(): - instantiate_testrail.update_testrail(case_id=test_cases["5g_eap_nat"], run_id=instantiate_project, - status_id=1, - msg='5G WPA2 ENTERPRISE Client Connectivity Passed successfully - ' - 'nat mode' + str(run_results)) - else: - instantiate_testrail.update_testrail(case_id=test_cases["5g_eap_nat"], run_id=instantiate_project, - status_id=5, - msg='5G WPA2 ENTERPRISE Client Connectivity Failed - nat mode' + str(run_results)) - assert eap_connect.passes() - - @pytest.mark.modify_ssid - @pytest.mark.parametrize( - 'update_ssid', - (["NAT, WPA, 5G, Sanity-updated-5G-WPA-NAT"]), - indirect=True - ) - def test_modify_ssid(self, request, update_ssid, get_lanforge_data, setup_profile_data, instantiate_testrail, - instantiate_project, test_cases, instantiate_controller): - profile_data = setup_profile_data["NAT"]["WPA"]["5G"] - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) - staConnect = StaConnect2(get_lanforge_data["lanforge_ip"], int(get_lanforge_data["lanforge-port-number"]), - debug_=False) - staConnect.sta_mode = 0 - staConnect.upstream_resource = 1 - staConnect.upstream_port = get_lanforge_data["lanforge_bridge_port"] - staConnect.radio = get_lanforge_data["lanforge_5g"] - staConnect.resource = 1 - staConnect.dut_ssid = profile_data["ssid_name"] - staConnect.dut_passwd = profile_data["security_key"] - staConnect.dut_security = "wpa" - staConnect.station_names = station_names - staConnect.sta_prefix = get_lanforge_data["lanforge_5g_prefix"] - staConnect.runtime_secs = 10 - staConnect.bringup_time_sec = 60 - staConnect.cleanup_on_exit = True - # staConnect.cleanup() - staConnect.setup() - staConnect.start() - print("napping %f sec" % staConnect.runtime_secs) - time.sleep(staConnect.runtime_secs) - staConnect.stop() - staConnect.cleanup() - run_results = staConnect.get_result_list() - for result in run_results: - print("test result: " + result) - # result = 'pass' - print("Single Client Connectivity :", staConnect.passes) - if staConnect.passes(): - instantiate_testrail.update_testrail(case_id=test_cases["nat_ssid_update"], run_id=instantiate_project, - status_id=1, - msg='5G WPA Client Connectivity Passed successfully - nat mode ' - 'updated ssid' + str(run_results)) - else: - instantiate_testrail.update_testrail(case_id=test_cases["nat_ssid_update"], run_id=instantiate_project, - status_id=5, - msg='5G WPA Client Connectivity Failed - nat mode updated ssid' + str(run_results)) - instantiate_controller.refresh_instance() - assert staConnect.passes() diff --git a/tests/e2e/basic/client_connectivity_test/test_vlan_mode.py b/tests/e2e/basic/client_connectivity_test/test_vlan_mode.py deleted file mode 100644 index 534fc9755..000000000 --- a/tests/e2e/basic/client_connectivity_test/test_vlan_mode.py +++ /dev/null @@ -1,376 +0,0 @@ -""" - Test Case Module: Client Connectivity Test - Mode: VLAN - -""" - - -import pytest -import sys - -pytestmark = [pytest.mark.client_connectivity_test, pytest.mark.vlan] - -for folder in 'py-json', 'py-scripts': - if folder not in sys.path: - sys.path.append(f'../lanforge/lanforge-scripts/{folder}') - -sys.path.append(f"../lanforge/lanforge-scripts/py-scripts/tip-cicd-something") - -sys.path.append(f'../libs') -sys.path.append(f'../libs/lanforge/') - -from LANforge.LFUtils import * - -if 'py-json' not in sys.path: - sys.path.append('../py-scripts') - -from sta_connect2 import StaConnect2 -from eap_connect import EAPConnect -import time - - -@pytest.mark.sanity -@pytest.mark.vlan -@pytest.mark.wifi5 -@pytest.mark.wifi6 -@pytest.mark.parametrize( - 'setup_profiles, create_profiles', - [(["VLAN"], ["VLAN"])], - indirect=True, - scope="class" -) -@pytest.mark.usefixtures("setup_profiles") -@pytest.mark.usefixtures("create_profiles") -class TestVlanModeClientConnectivity(object): - - @pytest.mark.wpa - @pytest.mark.twog - def test_client_wpa_2g(self, request, get_lanforge_data, setup_profile_data, - instantiate_testrail, instantiate_project, test_cases): - profile_data = setup_profile_data["VLAN"]["WPA"]["2G"] - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) - print(profile_data, get_lanforge_data) - staConnect = StaConnect2(get_lanforge_data["lanforge_ip"], int(get_lanforge_data["lanforge-port-number"]), - debug_=False) - staConnect.sta_mode = 0 - staConnect.upstream_resource = 1 - staConnect.upstream_port = get_lanforge_data["lanforge_vlan_port"] - staConnect.radio = get_lanforge_data["lanforge_2dot4g"] - staConnect.resource = 1 - staConnect.dut_ssid = profile_data["ssid_name"] - staConnect.dut_passwd = profile_data["security_key"] - staConnect.dut_security = "wpa" - staConnect.station_names = station_names - staConnect.sta_prefix = get_lanforge_data["lanforge_2dot4g_prefix"] - staConnect.runtime_secs = 10 - staConnect.bringup_time_sec = 60 - staConnect.cleanup_on_exit = True - staConnect.setup() - staConnect.start() - print("napping %f sec" % staConnect.runtime_secs) - time.sleep(staConnect.runtime_secs) - staConnect.stop() - staConnect.cleanup() - run_results = staConnect.get_result_list() - for result in run_results: - print("test result: " + result) - # result = 'pass' - print("Single Client Connectivity :", staConnect.passes) - if staConnect.passes(): - instantiate_testrail.update_testrail(case_id=test_cases["2g_wpa_vlan"], run_id=instantiate_project, - status_id=1, - msg='2G WPA Client Connectivity Passed successfully - vlan mode' + str(run_results)) - else: - instantiate_testrail.update_testrail(case_id=test_cases["2g_wpa_vlan"], run_id=instantiate_project, - status_id=5, - msg='2G WPA Client Connectivity Failed - vlan mode' + str(run_results)) - assert staConnect.passes() - # C2420 - - @pytest.mark.wpa - @pytest.mark.fiveg - def test_client_wpa_5g(self, request, get_lanforge_data, setup_profile_data, - instantiate_project, instantiate_testrail, test_cases): - profile_data = setup_profile_data["VLAN"]["WPA"]["5G"] - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) - staConnect = StaConnect2(get_lanforge_data["lanforge_ip"], int(get_lanforge_data["lanforge-port-number"]), - debug_=False) - staConnect.sta_mode = 0 - staConnect.upstream_resource = 1 - staConnect.upstream_port = get_lanforge_data["lanforge_vlan_port"] - staConnect.radio = get_lanforge_data["lanforge_5g"] - staConnect.resource = 1 - staConnect.dut_ssid = profile_data["ssid_name"] - staConnect.dut_passwd = profile_data["security_key"] - staConnect.dut_security = "wpa" - staConnect.station_names = station_names - staConnect.sta_prefix = get_lanforge_data["lanforge_5g_prefix"] - staConnect.runtime_secs = 10 - staConnect.bringup_time_sec = 60 - staConnect.cleanup_on_exit = True - # staConnect.cleanup() - staConnect.setup() - staConnect.start() - print("napping %f sec" % staConnect.runtime_secs) - time.sleep(staConnect.runtime_secs) - staConnect.stop() - staConnect.cleanup() - run_results = staConnect.get_result_list() - for result in run_results: - print("test result: " + result) - # result = 'pass' - print("Single Client Connectivity :", staConnect.passes) - if staConnect.passes(): - instantiate_testrail.update_testrail(case_id=test_cases["5g_wpa_vlan"], run_id=instantiate_project, - status_id=1, - msg='5G WPA Client Connectivity Passed successfully - vlan mode' + str(run_results)) - else: - instantiate_testrail.update_testrail(case_id=test_cases["5g_wpa_vlan"], run_id=instantiate_project, - status_id=5, - msg='5G WPA Client Connectivity Failed - vlan mode' + str(run_results)) - assert staConnect.passes() - # C2419 - - @pytest.mark.wpa2_personal - @pytest.mark.twog - def test_client_wpa2_personal_2g(self, request, get_lanforge_data, setup_profile_data, - instantiate_project, instantiate_testrail, test_cases): - profile_data = setup_profile_data["VLAN"]["WPA2_P"]["2G"] - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) - staConnect = StaConnect2(get_lanforge_data["lanforge_ip"], int(get_lanforge_data["lanforge-port-number"]), - debug_=False) - staConnect.sta_mode = 0 - staConnect.upstream_resource = 1 - staConnect.upstream_port = get_lanforge_data["lanforge_vlan_port"] - staConnect.radio = get_lanforge_data["lanforge_2dot4g"] - staConnect.resource = 1 - staConnect.dut_ssid = profile_data["ssid_name"] - staConnect.dut_passwd = profile_data["security_key"] - staConnect.dut_security = "wpa2" - staConnect.station_names = station_names - staConnect.sta_prefix = get_lanforge_data["lanforge_2dot4g_prefix"] - staConnect.runtime_secs = 10 - staConnect.bringup_time_sec = 60 - staConnect.cleanup_on_exit = True - # staConnect.cleanup() - staConnect.setup() - staConnect.start() - print("napping %f sec" % staConnect.runtime_secs) - time.sleep(staConnect.runtime_secs) - staConnect.stop() - staConnect.cleanup() - run_results = staConnect.get_result_list() - for result in run_results: - print("test result: " + result) - # result = 'pass' - print("Single Client Connectivity :", staConnect.passes) - if staConnect.passes(): - instantiate_testrail.update_testrail(case_id=test_cases["2g_wpa2_vlan"], run_id=instantiate_project, - status_id=1, - msg='2G WPA2 Client Connectivity Passed successfully - vlan mode' + str(run_results)) - else: - instantiate_testrail.update_testrail(case_id=test_cases["2g_wpa2_vlan"], run_id=instantiate_project, - status_id=5, - msg='2G WPA2 Client Connectivity Failed - vlan mode' + str(run_results)) - assert staConnect.passes() - # C2237 - - @pytest.mark.wpa2_personal - @pytest.mark.fiveg - def test_client_wpa2_personal_5g(self, request, get_lanforge_data, setup_profile_data, - instantiate_project, instantiate_testrail, test_cases): - profile_data = setup_profile_data["VLAN"]["WPA2_P"]["5G"] - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) - staConnect = StaConnect2(get_lanforge_data["lanforge_ip"], int(get_lanforge_data["lanforge-port-number"]), - debug_=False) - staConnect.sta_mode = 0 - staConnect.upstream_resource = 1 - staConnect.upstream_port = get_lanforge_data["lanforge_vlan_port"] - staConnect.radio = get_lanforge_data["lanforge_5g"] - staConnect.resource = 1 - staConnect.dut_ssid = profile_data["ssid_name"] - staConnect.dut_passwd = profile_data["security_key"] - staConnect.dut_security = "wpa2" - staConnect.station_names = station_names - staConnect.sta_prefix = get_lanforge_data["lanforge_5g_prefix"] - staConnect.runtime_secs = 10 - staConnect.bringup_time_sec = 60 - staConnect.cleanup_on_exit = True - # staConnect.cleanup() - staConnect.setup() - staConnect.start() - print("napping %f sec" % staConnect.runtime_secs) - time.sleep(staConnect.runtime_secs) - staConnect.stop() - staConnect.cleanup() - run_results = staConnect.get_result_list() - for result in run_results: - print("test result: " + result) - # result = 'pass' - print("Single Client Connectivity :", staConnect.passes) - if staConnect.passes(): - instantiate_testrail.update_testrail(case_id=test_cases["5g_wpa2_vlan"], run_id=instantiate_project, - status_id=1, - msg='5G WPA2 Client Connectivity Passed successfully - vlan mode' + str(run_results)) - else: - instantiate_testrail.update_testrail(case_id=test_cases["5g_wpa2_vlan"], run_id=instantiate_project, - status_id=5, - msg='5G WPA2 Client Connectivity Failed - vlan mode' + str(run_results)) - assert staConnect.passes() - # C2236 - - @pytest.mark.wpa2_enterprise - @pytest.mark.twog - @pytest.mark.radius - def test_client_wpa2_enterprise_2g(self, request, get_lanforge_data, setup_profile_data, instantiate_project, - instantiate_testrail, radius_info, test_cases): - profile_data = setup_profile_data["VLAN"]["WPA2_E"]["2G"] - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) - eap_connect = EAPConnect(get_lanforge_data["lanforge_ip"], get_lanforge_data["lanforge-port-number"]) - eap_connect.upstream_resource = 1 - eap_connect.upstream_port = get_lanforge_data["lanforge_vlan_port"] - eap_connect.security = "wpa2" - eap_connect.sta_list = station_names - eap_connect.station_names = station_names - eap_connect.sta_prefix = get_lanforge_data["lanforge_2dot4g_prefix"] - eap_connect.ssid = profile_data["ssid_name"] - eap_connect.radio = get_lanforge_data["lanforge_2dot4g"] - eap_connect.eap = "TTLS" - eap_connect.identity = radius_info["user"] - eap_connect.ttls_passwd = radius_info["password"] - eap_connect.runtime_secs = 10 - eap_connect.setup() - eap_connect.start() - print("napping %f sec" % eap_connect.runtime_secs) - time.sleep(eap_connect.runtime_secs) - eap_connect.stop() - try: - eap_connect.cleanup() - eap_connect.cleanup() - except Exception as e: - print(e) - run_results = eap_connect.get_result_list() - for result in run_results: - print("test result: " + result) - # result = 'pass' - print("Single Client Connectivity :", eap_connect.passes) - if eap_connect.passes(): - instantiate_testrail.update_testrail(case_id=test_cases["2g_eap_vlan"], run_id=instantiate_project, - status_id=1, - msg='5G WPA2 ENTERPRISE Client Connectivity Passed successfully - ' - 'vlan mode' + str(run_results)) - else: - instantiate_testrail.update_testrail(case_id=test_cases["2g_eap_vlan"], run_id=instantiate_project, - status_id=5, - msg='5G WPA2 ENTERPRISE Client Connectivity Failed - vlan mode' + str(run_results)) - assert eap_connect.passes() - # C5214 - - @pytest.mark.wpa2_enterprise - @pytest.mark.fiveg - @pytest.mark.radius - def test_client_wpa2_enterprise_5g(self, request, get_lanforge_data, setup_profile_data, instantiate_project, - instantiate_testrail, radius_info, test_cases): - profile_data = setup_profile_data["VLAN"]["WPA2_E"]["5G"] - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) - eap_connect = EAPConnect(get_lanforge_data["lanforge_ip"], get_lanforge_data["lanforge-port-number"]) - eap_connect.upstream_resource = 1 - eap_connect.upstream_port = get_lanforge_data["lanforge_vlan_port"] - eap_connect.security = "wpa2" - eap_connect.sta_list = station_names - eap_connect.station_names = station_names - eap_connect.sta_prefix = get_lanforge_data["lanforge_5g_prefix"] - eap_connect.ssid = profile_data["ssid_name"] - eap_connect.radio = get_lanforge_data["lanforge_5g"] - eap_connect.eap = "TTLS" - eap_connect.identity = radius_info["user"] - eap_connect.ttls_passwd = radius_info["password"] - eap_connect.runtime_secs = 10 - eap_connect.setup() - eap_connect.start() - print("napping %f sec" % eap_connect.runtime_secs) - time.sleep(eap_connect.runtime_secs) - eap_connect.stop() - try: - eap_connect.cleanup() - eap_connect.cleanup() - except Exception as e: - print(e) - run_results = eap_connect.get_result_list() - for result in run_results: - print("test result: " + result) - # result = 'pass' - print("Single Client Connectivity :", eap_connect.passes) - if eap_connect.passes(): - instantiate_testrail.update_testrail(case_id=test_cases["5g_eap_vlan"], run_id=instantiate_project, - status_id=1, - msg='5G WPA2 ENTERPRISE Client Connectivity Passed successfully - ' - 'vlan mode' + str(run_results)) - else: - instantiate_testrail.update_testrail(case_id=test_cases["5g_eap_vlan"], run_id=instantiate_project, - status_id=5, - msg='5G WPA2 ENTERPRISE Client Connectivity Failed - vlan mode' + str(run_results)) - assert eap_connect.passes() - - @pytest.mark.modify_ssid - @pytest.mark.parametrize( - 'update_ssid', - (["VLAN, WPA, 5G, Sanity-updated-5G-WPA-VLAN"]), - indirect=True - ) - def test_modify_ssid(self, request, update_ssid, get_lanforge_data, setup_profile_data, instantiate_testrail, - instantiate_project, test_cases, instantiate_controller): - profile_data = setup_profile_data["VLAN"]["WPA"]["5G"] - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) - staConnect = StaConnect2(get_lanforge_data["lanforge_ip"], int(get_lanforge_data["lanforge-port-number"]), - debug_=False) - staConnect.sta_mode = 0 - staConnect.upstream_resource = 1 - staConnect.upstream_port = get_lanforge_data["lanforge_bridge_port"] - staConnect.radio = get_lanforge_data["lanforge_5g"] - staConnect.resource = 1 - staConnect.dut_ssid = profile_data["ssid_name"] - staConnect.dut_passwd = profile_data["security_key"] - staConnect.dut_security = "wpa" - staConnect.station_names = station_names - staConnect.sta_prefix = get_lanforge_data["lanforge_5g_prefix"] - staConnect.runtime_secs = 10 - staConnect.bringup_time_sec = 60 - staConnect.cleanup_on_exit = True - # staConnect.cleanup() - staConnect.setup() - staConnect.start() - print("napping %f sec" % staConnect.runtime_secs) - time.sleep(staConnect.runtime_secs) - staConnect.stop() - staConnect.cleanup() - run_results = staConnect.get_result_list() - for result in run_results: - print("test result: " + result) - # result = 'pass' - print("Single Client Connectivity :", staConnect.passes) - if staConnect.passes(): - instantiate_testrail.update_testrail(case_id=test_cases["vlan_ssid_update"], run_id=instantiate_project, - status_id=1, - msg='5G WPA Client Connectivity Passed successfully - vlan mode ' - 'updated ssid' + str(run_results)) - else: - instantiate_testrail.update_testrail(case_id=test_cases["vlan_ssid_update"], run_id=instantiate_project, - status_id=5, - msg='5G WPA Client Connectivity Failed - vlan mode updated ssid' + str(run_results)) - instantiate_controller.refresh_instance() - assert staConnect.passes() diff --git a/tests/e2e/basic/client_connectivity_test/vlan/__init__.py b/tests/e2e/basic/client_connectivity_test/vlan/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/e2e/basic/client_connectivity_test/vlan/basic_security_modes/__init__.py b/tests/e2e/basic/client_connectivity_test/vlan/basic_security_modes/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/e2e/basic/client_connectivity_test/vlan/basic_security_modes/test_basic_security.py b/tests/e2e/basic/client_connectivity_test/vlan/basic_security_modes/test_basic_security.py new file mode 100644 index 000000000..410dc7071 --- /dev/null +++ b/tests/e2e/basic/client_connectivity_test/vlan/basic_security_modes/test_basic_security.py @@ -0,0 +1,78 @@ +import pytest +import allure + +pytestmark = [pytest.mark.client_connectivity, pytest.mark.vlan] + +setup_params_general = { + "mode": "VLAN", + "ssid_modes": { + "open": [{"ssid_name": "ssid_open_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_open_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], + "wpa": [{"ssid_name": "ssid_wpa_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa2_personal": [ + {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}]}, + "rf": {}, + "radius": False +} + + +@allure.feature("VLAN MODE CLIENT CONNECTIVITY") +@pytest.mark.parametrize( + 'setup_client_connectivity', + [setup_params_general], + indirect=True, + scope="package" +) +@pytest.mark.usefixtures("setup_client_connectivity") +class TestVLANModeConnectivity(object): + + + @pytest.mark.open + @pytest.mark.twog + @allure.story('open 2.4 GHZ Band') + def test_open_ssid_2g(self): + ssid_data = setup_params_general["ssid_modes"]["open"][0] + + assert "setup_client_connectivity" + + @pytest.mark.open + @pytest.mark.fiveg + @allure.story('open 5 GHZ Band') + def test_open_ssid_5g(self): + ssid_data = setup_params_general["ssid_modes"]["open"][1] + assert "setup_client_connectivity" + + @pytest.mark.wpa + @pytest.mark.twog + @allure.story('wpa 2.4 GHZ Band') + def test_wpa_ssid_2g(self): + ssid_data = setup_params_general["ssid_modes"]["wpa"][0] + # print(setup_client_connectivity) + assert "setup_client_connectivity" + + @pytest.mark.wpa + @pytest.mark.fiveg + @allure.story('wpa 5 GHZ Band') + def test_wpa_ssid_5g(self): + ssid_data = setup_params_general["ssid_modes"]["wpa"][1] + assert "setup_client_connectivity" + + @pytest.mark.wpa2_personal + @pytest.mark.twog + @allure.story('wpa2_personal 2.4 GHZ Band') + def test_wpa2_personal_ssid_2g(self): + ssid_data = setup_params_general["ssid_modes"]["wpa2_personal"][0] + # print(setup_client_connectivity) + assert "setup_client_connectivity" + + @pytest.mark.wpa2_personal + @pytest.mark.fiveg + @allure.story('wpa2_personal 5 GHZ Band') + def test_wpa2_personal_ssid_5g(self): + ssid_data = setup_params_general["ssid_modes"]["wpa2_personal"][1] + assert "setup_client_connectivity" + diff --git a/tests/e2e/basic/client_connectivity_test/vlan/basic_security_modes/test_configuration_basic_modes.py b/tests/e2e/basic/client_connectivity_test/vlan/basic_security_modes/test_configuration_basic_modes.py new file mode 100644 index 000000000..b5c07a1e6 --- /dev/null +++ b/tests/e2e/basic/client_connectivity_test/vlan/basic_security_modes/test_configuration_basic_modes.py @@ -0,0 +1,78 @@ +import pytest +import allure + +pytestmark = [pytest.mark.client_connectivity, pytest.mark.vlan, pytest.mark.configuration] + +setup_params_general = { + "mode": "VLAN", + "ssid_modes": { + "open": [{"ssid_name": "ssid_open_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_open_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], + "wpa": [{"ssid_name": "ssid_wpa_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa2_personal": [ + {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}]}, + "rf": {}, + "radius": False +} + + +@allure.feature("VLAN MODE CLIENT CONNECTIVITY") +@pytest.mark.parametrize( + 'setup_client_connectivity', + [setup_params_general], + indirect=True, + scope="package" +) +@pytest.mark.usefixtures("setup_client_connectivity") +class TestVLANModeConnectivity(object): + + + @pytest.mark.open + @pytest.mark.twog + @allure.story('open 2.4 GHZ Band') + def test_open_ssid_2g(self, setup_client_connectivity): + ssid_data = setup_params_general["ssid_modes"]["open"][0] + allure.attach(str(setup_client_connectivity), 'Hello, World') + assert setup_client_connectivity + + @pytest.mark.open + @pytest.mark.fiveg + @allure.story('open 5 GHZ Band') + def test_open_ssid_5g(self, setup_client_connectivity): + ssid_data = setup_params_general["ssid_modes"]["open"][1] + assert setup_client_connectivity + + @pytest.mark.wpa + @pytest.mark.twog + @allure.story('wpa 2.4 GHZ Band') + def test_wpa_ssid_2g(self, setup_client_connectivity): + ssid_data = setup_params_general["ssid_modes"]["wpa"][0] + print(setup_client_connectivity) + assert setup_client_connectivity + + @pytest.mark.wpa + @pytest.mark.fiveg + @allure.story('wpa 5 GHZ Band') + def test_wpa_ssid_5g(self, setup_client_connectivity): + ssid_data = setup_params_general["ssid_modes"]["wpa"][1] + assert setup_client_connectivity + + @pytest.mark.wpa2_personal + @pytest.mark.twog + @allure.story('wpa2_personal 2.4 GHZ Band') + def test_wpa2_personal_ssid_2g(self, setup_client_connectivity): + ssid_data = setup_params_general["ssid_modes"]["wpa2_personal"][0] + print(setup_client_connectivity) + assert setup_client_connectivity + + @pytest.mark.wpa2_personal + @pytest.mark.fiveg + @allure.story('wpa2_personal 5 GHZ Band') + def test_wpa2_personal_ssid_5g(self, setup_client_connectivity): + ssid_data = setup_params_general["ssid_modes"]["wpa2_personal"][1] + assert setup_client_connectivity + diff --git a/tests/e2e/basic/client_connectivity_test/vlan/enterprise_security_modes/__init__.py b/tests/e2e/basic/client_connectivity_test/vlan/enterprise_security_modes/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/e2e/basic/client_connectivity_test/vlan/enterprise_security_modes/test_configuration_enterprise_modes.py b/tests/e2e/basic/client_connectivity_test/vlan/enterprise_security_modes/test_configuration_enterprise_modes.py new file mode 100644 index 000000000..4c9a03b6d --- /dev/null +++ b/tests/e2e/basic/client_connectivity_test/vlan/enterprise_security_modes/test_configuration_enterprise_modes.py @@ -0,0 +1,55 @@ +import pytest +import allure + +pytestmark = [pytest.mark.client_connectivity, pytest.mark.enterprise, pytest.mark.bridge, pytest.mark.configuration] + +setup_params_enterprise = { + "mode": "BRIDGE", + "ssid_modes": { + "wpa2_enterprise": [ + {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa3_enterprise": [ + {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, + + "rf": {}, + "radius": True +} + + +@pytest.mark.parametrize( + 'setup_client_connectivity', + [setup_params_enterprise], + indirect=True, + scope="package" +) +@pytest.mark.usefixtures("setup_client_connectivity") +class TestBridgeModeEnterprise(object): + + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + def test_wpa2_enterprise_2g(self): + # print(setup_client_connectivity) + assert "setup_client_connectivity" + + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + def test_wpa2_enterprise_5g(self): + assert "setup_client_connectivity" + + @pytest.mark.wpa3_enterprise + @pytest.mark.twog + def test_wpa3_enterprise_2g(self): + # print(setup_client_connectivity) + assert "setup_client_connectivity" + + @pytest.mark.wpa3_enterprise + @pytest.mark.fiveg + def test_wpa3_enterprise_5g(self): + assert "setup_client_connectivity" + + + + diff --git a/tests/e2e/basic/client_connectivity_test/vlan/enterprise_security_modes/test_enterprise_security.py b/tests/e2e/basic/client_connectivity_test/vlan/enterprise_security_modes/test_enterprise_security.py new file mode 100644 index 000000000..5c53e5772 --- /dev/null +++ b/tests/e2e/basic/client_connectivity_test/vlan/enterprise_security_modes/test_enterprise_security.py @@ -0,0 +1,55 @@ +import pytest +import allure + +pytestmark = [pytest.mark.client_connectivity, pytest.mark.enterprise, pytest.mark.bridge] + +setup_params_enterprise = { + "mode": "BRIDGE", + "ssid_modes": { + "wpa2_enterprise": [ + {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa3_enterprise": [ + {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, + + "rf": {}, + "radius": True +} + + +@pytest.mark.parametrize( + 'setup_client_connectivity', + [setup_params_enterprise], + indirect=True, + scope="package" +) +@pytest.mark.usefixtures("setup_client_connectivity") +class TestBridgeModeEnterprise(object): + + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + def test_wpa2_enterprise_2g(self,): + # print(setup_client_connectivity) + assert "setup_client_connectivity" + + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + def test_wpa2_enterprise_5g(self): + assert "setup_client_connectivity" + + @pytest.mark.wpa3_enterprise + @pytest.mark.twog + def test_wpa3_enterprise_2g(self): + # print(setup_client_connectivity) + assert "setup_client_connectivity" + + @pytest.mark.wpa3_enterprise + @pytest.mark.fiveg + def test_wpa3_enterprise_5g(self): + assert "setup_client_connectivity" + + + + diff --git a/tests/e2e/basic/conftest.py b/tests/e2e/basic/conftest.py index 1ff8b379b..902b33d25 100644 --- a/tests/e2e/basic/conftest.py +++ b/tests/e2e/basic/conftest.py @@ -1,86 +1,14 @@ -""" -conftest.py : Contains fixtures that are specific to basic testbed environment - -Basic Test Scenario : 1 AP, 1 LANforge, 1 Controller Instance - -Includes: - - Setup: - setup_profiles - create_profiles - - Utilities: - update_ssid - -Information: - Setup Fixtures: Every Test case Needs to use setup fixtures - Setup Fixtures can be customised for all different levels of execution: - session level - package level - module level - class level - function level - -""" - -import sys -import os import time -sys.path.append( - os.path.dirname( - os.path.realpath(__file__) - ) -) -if "libs" not in sys.path: - sys.path.append(f'../libs') - -from apnos.apnos import APNOS -from controller.controller import Controller -from controller.controller import ProfileUtility -from controller.controller import FirmwareUtility import pytest -import logging -from configuration import RADIUS_SERVER_DATA -from configuration import TEST_CASES -from configuration import CONFIGURATION -from configuration import FIRMWARE -from testrails.testrail_api import APIClient -from testrails.reporting import Reporting - -""" -Basic Setup Collector -""" +import allure -@pytest.fixture(scope="function") -def get_lanforge_data(testbed): - lanforge_data = {} - if CONFIGURATION[testbed]['traffic_generator']['name'] == 'lanforge': - lanforge_data = { - "lanforge_ip": CONFIGURATION[testbed]['traffic_generator']['details']['ip'], - "lanforge-port-number": CONFIGURATION[testbed]['traffic_generator']['details']['port'], - "lanforge_2dot4g": CONFIGURATION[testbed]['traffic_generator']['details']['2.4G-Radio'][0], - "lanforge_5g": CONFIGURATION[testbed]['traffic_generator']['details']['5G-Radio'][0], - "lanforge_2dot4g_prefix": CONFIGURATION[testbed]['traffic_generator']['details']['2.4G-Station-Name'], - "lanforge_5g_prefix": CONFIGURATION[testbed]['traffic_generator']['details']['5G-Station-Name'], - "lanforge_2dot4g_station": CONFIGURATION[testbed]['traffic_generator']['details']['2.4G-Station-Name'], - "lanforge_5g_station": CONFIGURATION[testbed]['traffic_generator']['details']['5G-Station-Name'], - "lanforge_bridge_port": CONFIGURATION[testbed]['traffic_generator']['details']['upstream'], - "lanforge_vlan_port": CONFIGURATION[testbed]['traffic_generator']['details']['upstream'] + ".100", - "vlan": 100 - } - yield lanforge_data - - -@pytest.fixture(scope="module") -def instantiate_profile(instantiate_controller): - try: - profile_object = ProfileUtility(sdk_client=instantiate_controller) - except: - profile_object = False - yield profile_object - +@pytest.fixture(scope="session") +def setup_vlan(): + vlan_id = [100] + allure.attach(body=str(vlan_id), name="VLAN Created: ") + yield vlan_id[0] @pytest.fixture(scope="session") def get_equipment_id(instantiate_controller, testbed): @@ -88,76 +16,322 @@ def get_equipment_id(instantiate_controller, testbed): if len(CONFIGURATION[testbed]['access_point']) == 1: equipment_id = instantiate_controller.get_equipment_id( serial_number=CONFIGURATION[testbed]['access_point'][0]['serial']) + print(equipment_id) yield equipment_id - -@pytest.fixture(scope="session") -def upload_firmware(should_upload_firmware, instantiate_firmware, get_latest_firmware): - firmware_id = instantiate_firmware.upload_fw_on_cloud(fw_version=get_latest_firmware, - force_upload=should_upload_firmware) - yield firmware_id - - -@pytest.fixture(scope="function") -def upgrade_firmware(request, instantiate_firmware, get_equipment_id, check_ap_firmware_cloud, get_latest_firmware, - should_upgrade_firmware): - if get_latest_firmware != check_ap_firmware_cloud: - if request.config.getoption("--skip-upgrade"): - status = "skip-upgrade" - else: - status = instantiate_firmware.upgrade_fw(equipment_id=get_equipment_id, force_upload=False, - force_upgrade=should_upgrade_firmware) - else: - if should_upgrade_firmware: - status = instantiate_firmware.upgrade_fw(equipment_id=get_equipment_id, force_upload=False, - force_upgrade=should_upgrade_firmware) - else: - status = "skip-upgrade" - yield status - - -@pytest.fixture(scope="function") -def check_ap_firmware_cloud(instantiate_controller, get_equipment_id): - yield instantiate_controller.get_ap_firmware_old_method(equipment_id=get_equipment_id) - - -""" - -Profiles Related Fixtures - -""" - - @pytest.fixture(scope="module") -def get_current_profile_cloud(instantiate_profile): +def instantiate_profile(instantiate_controller): + try: + profile_object = ProfileUtility(sdk_client=instantiate_controller) + except Exception as e: + profile_object = False + yield profile_object + + +@allure.feature("CLIENT CONNECTIVITY SETUP") +@pytest.fixture(scope="package") +def setup_client_connectivity(request, instantiate_controller, testbed, setup_vlan, get_equipment_id, + instantiate_profile, get_markers, + get_security_flags, get_configuration, radius_info, get_apnos): + instantiate_profile = instantiate_profile(sdk_client=instantiate_controller) + vlan_id, mode = 0, 0 + instantiate_profile.cleanup_objects() + parameter = dict(request.param) + test_cases = {} + profile_data = {} + if parameter['mode'] not in ["BRIDGE", "NAT", "VLAN"]: + print("Invalid Mode: ", parameter['mode']) + allure.attach(body=parameter['mode'], name="Invalid Mode: ") + yield test_cases + + if parameter['mode'] == "NAT": + mode = "NAT" + vlan_id = 1 + if parameter['mode'] == "BRIDGE": + mode = "BRIDGE" + vlan_id = 1 + if parameter['mode'] == "VLAN": + mode = "BRIDGE" + vlan_id = setup_vlan + + instantiate_profile.delete_profile_by_name(profile_name=testbed + "-Equipment-AP-" + parameter['mode']) + + profile_data["equipment_ap"] = {"profile_name": testbed + "-Equipment-AP-" + parameter['mode']} + profile_data["ssid"] = {} + for i in parameter["ssid_modes"]: + profile_data["ssid"][i] = [] + for j in range(len(parameter["ssid_modes"][i])): + profile_name = testbed + "-SSID-" + i + "-" + str(j) + "-" + parameter['mode'] + data = parameter["ssid_modes"][i][j] + data["profile_name"] = profile_name + if "mode" not in dict(data).keys(): + data["mode"] = mode + if "vlan" not in dict(data).keys(): + data["vlan"] = vlan_id + instantiate_profile.delete_profile_by_name(profile_name=profile_name) + profile_data["ssid"][i].append(data) + # print(profile_name) + # print(profile_data) + + instantiate_profile.delete_profile_by_name(profile_name=testbed + "-Automation-Radius-Profile-" + mode) + time.sleep(10) + """ + Setting up rf profile + """ + rf_profile_data = { + "name": "RF-Profile-" + testbed + "-" + parameter['mode'] + "-" + + get_configuration[testbed]['access_point'][0]['mode'] + } + + for i in parameter["rf"]: + rf_profile_data[i] = parameter['rf'][i] + # print(rf_profile_data) + + try: + instantiate_profile.delete_profile_by_name(profile_name=rf_profile_data['name']) + instantiate_profile.set_rf_profile(profile_data=rf_profile_data, + mode=get_configuration[testbed]['access_point'][0]['mode']) + allure.attach(body=str(rf_profile_data), + name="RF Profile Created : " + get_configuration[testbed]['access_point'][0]['mode']) + except Exception as e: + print(e) + allure.attach(body=str(e), name="Exception ") + + # Radius Profile Creation + if parameter["radius"]: + radius_info = radius_info + radius_info["name"] = testbed + "-Automation-Radius-Profile-" + testbed + instantiate_profile.delete_profile_by_name(profile_name=testbed + "-Automation-Radius-Profile-" + testbed) + try: + # pass + instantiate_profile.create_radius_profile(radius_info=radius_info) + allure.attach(body=str(radius_info), + name="Radius Profile Created") + test_cases['radius_profile'] = True + except Exception as e: + print(e) + test_cases['radius_profile'] = False + + # SSID Profile Creation + print(get_markers) + for mode in profile_data['ssid']: + if mode == "open": + for j in profile_data["ssid"][mode]: + # print(j) + if mode in get_markers.keys() and get_markers[mode]: + try: + if "twog" in get_markers.keys() and get_markers["twog"] and "is2dot4GHz" in list( + j["appliedRadios"]): + creates_profile = instantiate_profile.create_open_ssid_profile(profile_data=j) + test_cases["open_2g"] = True + allure.attach(body=str(creates_profile), + name="SSID Profile Created") + except Exception as e: + print(e) + test_cases["open_2g"] = False + allure.attach(body=str(e), + name="SSID Profile Creation Failed") + + try: + if "fiveg" in get_markers.keys() and get_markers["fiveg"] and "is5GHz" in list( + j["appliedRadios"]): + creates_profile = instantiate_profile.create_open_ssid_profile(profile_data=j) + test_cases["open_5g"] = True + allure.attach(body=str(creates_profile), + name="SSID Profile Created") + except Exception as e: + print(e) + test_cases["open_5g"] = False + allure.attach(body=str(e), + name="SSID Profile Creation Failed") + + if mode == "wpa": + for j in profile_data["ssid"][mode]: + # print(j) + if mode in get_markers.keys() and get_markers[mode]: + try: + if "twog" in get_markers.keys() and get_markers["twog"] and "is2dot4GHz" in list( + j["appliedRadios"]): + creates_profile = instantiate_profile.create_wpa_ssid_profile(profile_data=j) + test_cases["wpa_2g"] = True + allure.attach(body=str(creates_profile), + name="SSID Profile Created") + except Exception as e: + print(e) + test_cases["wpa_2g"] = False + allure.attach(body=str(e), + name="SSID Profile Creation Failed") + try: + if "fiveg" in get_markers.keys() and get_markers["fiveg"] and "is5GHz" in list( + j["appliedRadios"]): + creates_profile = instantiate_profile.create_wpa_ssid_profile(profile_data=j) + test_cases["wpa_5g"] = True + allure.attach(body=str(creates_profile), + name="SSID Profile Created") + except Exception as e: + print(e) + test_cases["wpa_5g"] = False + allure.attach(body=str(e), + name="SSID Profile Creation Failed") + if mode == "wpa2_personal": + for j in profile_data["ssid"][mode]: + # print(j) + if mode in get_markers.keys() and get_markers[mode]: + try: + if "twog" in get_markers.keys() and get_markers["twog"] and "is2dot4GHz" in list( + j["appliedRadios"]): + creates_profile = instantiate_profile.create_wpa2_personal_ssid_profile(profile_data=j) + test_cases["wpa2_personal_2g"] = True + allure.attach(body=str(creates_profile), + name="SSID Profile Created") + except Exception as e: + print(e) + test_cases["wpa2_personal_2g"] = False + allure.attach(body=str(e), + name="SSID Profile Creation Failed") + try: + if "fiveg" in get_markers.keys() and get_markers["fiveg"] and "is5GHz" in list( + j["appliedRadios"]): + creates_profile = instantiate_profile.create_wpa2_personal_ssid_profile(profile_data=j) + test_cases["wpa2_personal_5g"] = True + allure.attach(body=str(creates_profile), + name="SSID Profile Created") + except Exception as e: + print(e) + test_cases["wpa2_personal_5g"] = False + allure.attach(body=str(e), + name="SSID Profile Creation Failed") + + if mode == "wpa3_personal": + for j in profile_data["ssid"][mode]: + # print(j) + if mode in get_markers.keys() and get_markers[mode]: + try: + if "twog" in get_markers.keys() and get_markers["twog"] and "is2dot4GHz" in list( + j["appliedRadios"]): + creates_profile = instantiate_profile.create_wpa3_personal_ssid_profile(profile_data=j) + test_cases["wpa3_personal_2g"] = True + allure.attach(body=str(creates_profile), + name="SSID Profile Created") + except Exception as e: + print(e) + test_cases["wpa3_personal_2g"] = False + allure.attach(body=str(e), + name="SSID Profile Creation Failed") + try: + if "fiveg" in get_markers.keys() and get_markers["fiveg"] and "is5GHz" in list( + j["appliedRadios"]): + creates_profile = instantiate_profile.create_wpa3_personal_ssid_profile(profile_data=j) + test_cases["wpa3_personal_5g"] = True + allure.attach(body=str(creates_profile), + name="SSID Profile Created") + except Exception as e: + print(e) + test_cases["wpa3_personal_5g"] = False + allure.attach(body=str(e), + name="SSID Profile Creation Failed") + + if mode == "wpa2_enterprise": + for j in profile_data["ssid"][mode]: + # print(j) + if mode in get_markers.keys() and get_markers[mode]: + try: + if "twog" in get_markers.keys() and get_markers["twog"] and "is2dot4GHz" in list( + j["appliedRadios"]): + creates_profile = instantiate_profile.create_wpa2_enterprise_ssid_profile(profile_data=j) + test_cases["wpa2_enterprise_2g"] = True + allure.attach(body=str(creates_profile), + name="SSID Profile Created") + except Exception as e: + print(e) + test_cases["wpa2_enterprise_2g"] = False + allure.attach(body=str(e), + name="SSID Profile Creation Failed") + try: + if "fiveg" in get_markers.keys() and get_markers["fiveg"] and "is5GHz" in list( + j["appliedRadios"]): + creates_profile = instantiate_profile.create_wpa2_enterprise_ssid_profile(profile_data=j) + test_cases["wpa2_enterprise_5g"] = True + allure.attach(body=str(creates_profile), + name="SSID Profile Created") + except Exception as e: + print(e) + test_cases["wpa2_enterprise_5g"] = False + allure.attach(body=str(e), + name="SSID Profile Creation Failed") + + if mode == "wpa3_enterprise": + for j in profile_data["ssid"][mode]: + # print(j) + if mode in get_markers.keys() and get_markers[mode]: + try: + if "twog" in get_markers.keys() and get_markers["twog"] and "is2dot4GHz" in list( + j["appliedRadios"]): + creates_profile = instantiate_profile.create_wpa3_enterprise_ssid_profile(profile_data=j) + test_cases["wpa3_enterprise_2g"] = True + allure.attach(body=str(creates_profile), + name="SSID Profile Created") + except Exception as e: + print(e) + test_cases["wpa3_enterprise_2g"] = False + allure.attach(body=str(e), + name="SSID Profile Creation Failed") + try: + if "fiveg" in get_markers.keys() and get_markers["fiveg"] and "is5GHz" in list( + j["appliedRadios"]): + creates_profile = instantiate_profile.create_wpa3_enterprise_ssid_profile(profile_data=j) + test_cases["wpa3_enterprise_5g"] = True + allure.attach(body=str(creates_profile), + name="SSID Profile Created") + except Exception as e: + print(e) + test_cases["wpa3_enterprise_5g"] = False + allure.attach(body=str(e), + name="SSID Profile Creation Failed") + + # Equipment AP Profile Creation + try: + instantiate_profile.set_ap_profile(profile_data=profile_data['equipment_ap']) + test_cases["equipment_ap"] = True + allure.attach(body=str(profile_data['equipment_ap']), + name="Equipment AP Profile Created") + except Exception as e: + print(e) + test_cases["equipment_ap"] = False + allure.attach(body=str(e), + name="Equipment AP Profile Creation Failed") + + # Push the Equipment AP Profile to AP + try: + instantiate_profile.push_profile_old_method(equipment_id=get_equipment_id) + except Exception as e: + print(e) + print("failed to create AP Profile") + + ap_ssh = get_apnos(get_configuration[testbed]['access_point'][0], pwd="../libs/apnos/") ssid_names = [] for i in instantiate_profile.profile_creation_ids["ssid"]: ssid_names.append(instantiate_profile.get_ssid_name_by_profile_id(profile_id=i)) - yield ssid_names + ssid_names.sort() - -@pytest.fixture(scope="module") -def setup_profiles(request, create_profiles, instantiate_profile, get_equipment_id, get_current_profile_cloud, testbed): - test_cases = {} - mode = str(request.param[0]).lower() - try: - instantiate_profile.push_profile_old_method(equipment_id=get_equipment_id) - except: - print("failed to create AP Profile") - ap_ssh = APNOS(CONFIGURATION[testbed]['access_point'][0], pwd="../libs/apnos/") - get_current_profile_cloud.sort() # This loop will check the VIF Config with cloud profile + vif_config = [] + test_cases['vifc'] = False for i in range(0, 18): vif_config = list(ap_ssh.get_vif_config_ssids()) vif_config.sort() print(vif_config) - print(get_current_profile_cloud) - if get_current_profile_cloud == vif_config: - test_cases[mode + '_vifc'] = True + print(ssid_names) + if ssid_names == vif_config: + test_cases['vifc'] = True break time.sleep(10) - ap_ssh = APNOS(CONFIGURATION[testbed]['access_point'][0], pwd="../libs/apnos/") + allure.attach(body=str("VIF Config: " + str(vif_config) + "\n" + "SSID Pushed from Controller: " + str(ssid_names)), + name="SSID Profiles in VIF Config and Controller: ") + ap_ssh = get_apnos(get_configuration[testbed]['access_point'][0], pwd="../libs/apnos/") + # This loop will check the VIF Config with VIF State + test_cases['vifs'] = False for i in range(0, 18): vif_state = list(ap_ssh.get_vif_state_ssids()) vif_state.sort() @@ -166,164 +340,22 @@ def setup_profiles(request, create_profiles, instantiate_profile, get_equipment_ print(vif_config) print(vif_state) if vif_state == vif_config: - test_cases[mode + '_vifs'] = True + test_cases['vifs'] = True break time.sleep(10) - # + allure.attach(body=str("VIF Config: " + str(vif_config) + "\n" + "VIF State: " + str(vif_state)), + name="SSID Profiles in VIF Config and VIF State: ") + print(test_cases) + + def teardown_session(): + print("\nRemoving Profiles") + instantiate_profile.delete_profile_by_name(profile_name=profile_data['equipment_ap']['profile_name']) + instantiate_profile.delete_profile(instantiate_profile.profile_creation_ids["ssid"]) + instantiate_profile.delete_profile(instantiate_profile.profile_creation_ids["radius"]) + instantiate_profile.delete_profile(instantiate_profile.profile_creation_ids["rf"]) + allure.attach(body=str(profile_data['equipment_ap']['profile_name'] + "\n"), + name="Tear Down in Profiles ") + time.sleep(20) + + request.addfinalizer(teardown_session) yield test_cases - - -@pytest.fixture(scope="module") -def create_profiles(request, testbed, get_security_flags, get_markers, instantiate_profile, setup_profile_data): - profile_id = {"ssid": [], "rf": None, "radius": None, "equipment_ap": None} - mode = str(request.param[0]) - test_cases = {} - if mode not in ["BRIDGE", "NAT", "VLAN"]: - print("Invalid Mode: ", mode) - yield False - instantiate_profile.delete_profile_by_name(profile_name=testbed + "-Equipment-AP-" + mode) - for i in setup_profile_data[mode]: - for j in setup_profile_data[mode][i]: - instantiate_profile.delete_profile_by_name( - profile_name=setup_profile_data[mode][i][j]['profile_name']) - instantiate_profile.delete_profile_by_name(profile_name=testbed + "-Automation-Radius-Profile-" + mode) - instantiate_profile.get_default_profiles() - profile_data = { - "name": "RF-Profile-" + CONFIGURATION[testbed]['access_point'][0]['mode'] + - CONFIGURATION[testbed]['access_point'][0]['model'] + mode - } - instantiate_profile.delete_profile_by_name(profile_name=profile_data['name']) - instantiate_profile.set_rf_profile(profile_data=profile_data, - mode=CONFIGURATION[testbed]['access_point'][0]['mode']) - # Create RF Profile Here - if get_markers["radius"]: - radius_info = RADIUS_SERVER_DATA - radius_info["name"] = testbed + "-Automation-Radius-Profile-" + mode - try: - instantiate_profile.create_radius_profile(radius_info=radius_info) - test_cases['radius_profile'] = True - except: - test_cases['radius_profile'] = False - for i in get_security_flags: - if get_markers[i] and i == "open": - if get_markers["twog"]: - profile_data = setup_profile_data[mode]["OPEN"]["2G"] - try: - id = instantiate_profile.create_open_ssid_profile(two4g=True, fiveg=False, - profile_data=profile_data) - profile_id["ssid"].append(profile_data['ssid_name']) - test_cases['ssid_2g_open_' + mode.lower()] = True - except: - test_cases['ssid_2g_open_' + mode.lower()] = False - if get_markers["fiveg"]: - profile_data = setup_profile_data[mode]["OPEN"]["5G"] - try: - id = instantiate_profile.create_open_ssid_profile(two4g=False, fiveg=True, - profile_data=profile_data) - profile_id["ssid"].append(profile_data['ssid_name']) - test_cases['ssid_5g_open_' + mode.lower()] = True - except: - test_cases['ssid_5g_open_' + mode.lower()] = False - if get_markers[i] and i == "wpa": - if get_markers["twog"]: - profile_data = setup_profile_data[mode]["WPA"]["2G"] - try: - id = instantiate_profile.create_wpa_ssid_profile(two4g=True, fiveg=False, profile_data=profile_data) - profile_id["ssid"].append(profile_data['ssid_name']) - test_cases['ssid_2g_wpa_' + mode.lower()] = True - except: - test_cases['ssid_5g_wpa_' + mode.lower()] = False - if get_markers["fiveg"]: - profile_data = setup_profile_data[mode]["WPA"]["5G"] - try: - id = instantiate_profile.create_wpa_ssid_profile(two4g=False, fiveg=True, profile_data=profile_data) - profile_id["ssid"].append(profile_data['ssid_name']) - test_cases['ssid_5g_wpa_' + mode.lower()] = True - except: - test_cases['ssid_5g_wpa_' + mode.lower()] = False - if get_markers[i] and i == "wpa2_personal": - if get_markers["twog"]: - profile_data = setup_profile_data[mode]["WPA2_P"]["2G"] - try: - id = instantiate_profile.create_wpa2_personal_ssid_profile(two4g=True, fiveg=False, - profile_data=profile_data) - profile_id["ssid"].append(profile_data['ssid_name']) - test_cases['ssid_2g_wpa2_' + mode.lower()] = True - except: - test_cases['ssid_2g_wpa2_' + mode.lower()] = False - if get_markers["fiveg"]: - profile_data = setup_profile_data[mode]["WPA2_P"]["5G"] - try: - id = instantiate_profile.create_wpa2_personal_ssid_profile(two4g=False, fiveg=True, - profile_data=profile_data) - profile_id["ssid"].append(profile_data['ssid_name']) - test_cases['ssid_5g_wpa2_' + mode.lower()] = True - except: - test_cases['ssid_5g_wpa2_' + mode.lower()] = False - if get_markers[i] and i == "wpa2_enterprise": - if get_markers["twog"]: - profile_data = setup_profile_data[mode]["WPA2_E"]["2G"] - try: - id = instantiate_profile.create_wpa2_enterprise_ssid_profile(two4g=True, fiveg=False, - profile_data=profile_data) - profile_id["ssid"].append(profile_data['ssid_name']) - test_cases['ssid_2g_eap_' + mode.lower()] = True - except: - test_cases['ssid_2g_eap_' + mode.lower()] = False - if get_markers["fiveg"]: - profile_data = setup_profile_data[mode]["WPA2_E"]["5G"] - try: - id = instantiate_profile.create_wpa2_enterprise_ssid_profile(two4g=False, fiveg=True, - profile_data=profile_data) - profile_id["ssid"].append(profile_data['ssid_name']) - test_cases['ssid_5g_eap_' + mode.lower()] = True - except: - test_cases['ssid_5g_eap_' + mode.lower()] = False - - - - # Create Equipment AP Profile Here - profile_data = { - "profile_name": testbed + "-Equipment-AP-" + mode - } - try: - instantiate_profile.set_ap_profile(profile_data=profile_data) - test_cases['ap_' + mode.lower()] = True - except: - test_cases['ap_' + mode.lower()] = False - yield test_cases - - -@pytest.fixture(scope="function") -def update_ssid(request, instantiate_profile, setup_profile_data): - requested_profile = str(request.param).replace(" ", "").split(",") - profile = setup_profile_data[requested_profile[0]][requested_profile[1]][requested_profile[2]] - status = instantiate_profile.update_ssid_name(profile_name=profile["profile_name"], - new_profile_name=requested_profile[3]) - setup_profile_data[requested_profile[0]][requested_profile[1]][requested_profile[2]]["profile_name"] = \ - requested_profile[3] - setup_profile_data[requested_profile[0]][requested_profile[1]][requested_profile[2]]["ssid_name"] = \ - requested_profile[3] - time.sleep(90) - yield status - - -@pytest.fixture(scope="package") -def configure_lanforge(instantiate_dut): - # Scenario build - # - scenario_obj = Class() - yield scenario_obj - - -@pytest.fixture(scope="package") -def instantiate_dut(): - dut_obj = DUT("") - dut_obj.update() - # - yield dut_obj - -@pytest.fixture(scope="package") -def setup_vlan(scenario_obj): - scenario_obj.create_vlan() - yield scenario_obj \ No newline at end of file diff --git a/tests/pytest.ini b/tests/pytest.ini index 6208b26b3..a017ff8b5 100644 --- a/tests/pytest.ini +++ b/tests/pytest.ini @@ -4,7 +4,7 @@ norecursedirs = .svn _build tmp* addopts= --junitxml=test_everything.xml log_format = %(asctime)s %(levelname)s %(message)s log_date_format = %Y-%m-%d %H:%M:%S - +;norecursedirs=out build num_stations=1 # Cloud SDK settings diff --git a/tests/test_connectivity.py b/tests/test_connectivity.py index 4a7b6be41..5c0472034 100644 --- a/tests/test_connectivity.py +++ b/tests/test_connectivity.py @@ -56,10 +56,10 @@ def test_lanforge_connectivity(check_lanforge_connectivity): assert "instantiate_cloudsdk" -@pytest.mark.sanity +@pytest.mark.shivam @pytest.mark.bridge @pytest.mark.nat @pytest.mark.vlan @pytest.mark.test_perfecto_connectivity -def test_perfecto_connectivity(setup_perfecto_devices): +def test_perfecto_connectivity(setup_controller): assert "instantiate_cloudsdk" From 9edce6c7a9c6cb1ec2de271e0c357e8c71288490 Mon Sep 17 00:00:00 2001 From: shivamcandela Date: Fri, 14 May 2021 14:50:57 +0530 Subject: [PATCH 04/21] client_connectivity updates Signed-off-by: shivamcandela --- lanforge/lanforge-scripts | 1 + libs/apnos/apnos.py | 1 + libs/controller/controller.py | 80 ++-- libs/lanforge/lf_tests.py | 81 +++-- tests/configuration.py | 166 +++++---- tests/conftest.py | 163 ++++----- .../air_time_fairness_test/__init__.py | 0 .../_basic_test_setup/setup__e2e_resources.py | 162 ++++----- .../test__configuration_basic_modes.py | 91 ----- .../test_basic_security.py | 124 ------- .../test_configuration_enterprise_modes.py | 55 --- .../test_enterprise_security.py | 55 --- .../client_connectivity_test/conftest.py | 344 ------------------ .../test_basic_security.py | 78 ---- .../test_configuration_basic_modes.py | 78 ---- .../test_configuration_enterprise_modes.py | 55 --- .../test_enterprise_security.py | 55 --- .../test_basic_security.py | 78 ---- .../test_configuration_basic_modes.py | 78 ---- .../test_configuration_enterprise_modes.py | 55 --- .../test_enterprise_security.py | 55 --- .../__init__.py | 0 tests/e2e/basic/conftest.py | 68 ++-- .../bridge => performance_tests}/__init__.py | 0 .../dataplane_throughput_test}/__init__.py | 0 .../dual_band_performance_test}/__init__.py | 0 .../wifi_capacity_test}/__init__.py | 0 .../wifi_capacity_test/test_bridge_mode.py | 0 .../wifi_capacity_test/test_nat_mode.py | 0 .../wifi_capacity_test/test_vlan_mode.py | 0 tests/e2e/basic/test_firmware.py | 81 +++++ .../__init__.py | 0 .../bridge_mode}/__init__.py | 0 .../client_connectivity}/__init__.py | 0 .../test_security_modes.py | 266 ++++++++++++++ .../nat_mode}/__init__.py | 0 .../nat_mode/client_connectivity}/__init__.py | 0 .../test_basic_security.py | 260 +++++++++++++ .../vlan_mode}/__init__.py | 0 .../client_connectivity}/__init__.py | 0 .../test_basic_security.py | 261 +++++++++++++ .../vlan_mode/default_vlan_tests}/__init__.py | 0 tests/test_connectivity.py | 94 ++--- 43 files changed, 1276 insertions(+), 1609 deletions(-) create mode 160000 lanforge/lanforge-scripts rename tests/e2e/{basic => advanced}/air_time_fairness_test/__init__.py (100%) delete mode 100644 tests/e2e/basic/client_connectivity_test/bridge/basic_security_modes/test__configuration_basic_modes.py delete mode 100644 tests/e2e/basic/client_connectivity_test/bridge/basic_security_modes/test_basic_security.py delete mode 100644 tests/e2e/basic/client_connectivity_test/bridge/enterprise_security_modes/test_configuration_enterprise_modes.py delete mode 100644 tests/e2e/basic/client_connectivity_test/bridge/enterprise_security_modes/test_enterprise_security.py delete mode 100644 tests/e2e/basic/client_connectivity_test/conftest.py delete mode 100644 tests/e2e/basic/client_connectivity_test/nat/basic_security_modes/test_basic_security.py delete mode 100644 tests/e2e/basic/client_connectivity_test/nat/basic_security_modes/test_configuration_basic_modes.py delete mode 100644 tests/e2e/basic/client_connectivity_test/nat/enterprise_security_modes/test_configuration_enterprise_modes.py delete mode 100644 tests/e2e/basic/client_connectivity_test/nat/enterprise_security_modes/test_enterprise_security.py delete mode 100644 tests/e2e/basic/client_connectivity_test/vlan/basic_security_modes/test_basic_security.py delete mode 100644 tests/e2e/basic/client_connectivity_test/vlan/basic_security_modes/test_configuration_basic_modes.py delete mode 100644 tests/e2e/basic/client_connectivity_test/vlan/enterprise_security_modes/test_configuration_enterprise_modes.py delete mode 100644 tests/e2e/basic/client_connectivity_test/vlan/enterprise_security_modes/test_enterprise_security.py rename tests/e2e/basic/{client_connectivity_test => configuration_tests}/__init__.py (100%) rename tests/e2e/basic/{client_connectivity_test/bridge => performance_tests}/__init__.py (100%) rename tests/e2e/basic/{client_connectivity_test/bridge/basic_security_modes => performance_tests/dataplane_throughput_test}/__init__.py (100%) rename tests/e2e/basic/{client_connectivity_test/bridge/enterprise_security_modes => performance_tests/dual_band_performance_test}/__init__.py (100%) rename tests/e2e/basic/{client_connectivity_test/nat => performance_tests/wifi_capacity_test}/__init__.py (100%) rename tests/e2e/basic/{ => performance_tests}/wifi_capacity_test/test_bridge_mode.py (100%) rename tests/e2e/basic/{ => performance_tests}/wifi_capacity_test/test_nat_mode.py (100%) rename tests/e2e/basic/{ => performance_tests}/wifi_capacity_test/test_vlan_mode.py (100%) create mode 100644 tests/e2e/basic/test_firmware.py rename tests/e2e/basic/{client_connectivity_test/nat/basic_security_modes => validation_of_operating_modes}/__init__.py (100%) rename tests/e2e/basic/{client_connectivity_test/nat/enterprise_security_modes => validation_of_operating_modes/bridge_mode}/__init__.py (100%) rename tests/e2e/basic/{client_connectivity_test/vlan => validation_of_operating_modes/bridge_mode/client_connectivity}/__init__.py (100%) create mode 100644 tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py rename tests/e2e/basic/{client_connectivity_test/vlan/basic_security_modes => validation_of_operating_modes/nat_mode}/__init__.py (100%) rename tests/e2e/basic/{client_connectivity_test/vlan/enterprise_security_modes => validation_of_operating_modes/nat_mode/client_connectivity}/__init__.py (100%) create mode 100644 tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_basic_security.py rename tests/e2e/basic/{dataplane_throughput_test => validation_of_operating_modes/vlan_mode}/__init__.py (100%) rename tests/e2e/basic/{dual_band_performance_test => validation_of_operating_modes/vlan_mode/client_connectivity}/__init__.py (100%) create mode 100644 tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_basic_security.py rename tests/e2e/basic/{wifi_capacity_test => validation_of_operating_modes/vlan_mode/default_vlan_tests}/__init__.py (100%) diff --git a/lanforge/lanforge-scripts b/lanforge/lanforge-scripts new file mode 160000 index 000000000..de86a454b --- /dev/null +++ b/lanforge/lanforge-scripts @@ -0,0 +1 @@ +Subproject commit de86a454b23ca2a211d18df792da7d75ec57e8a8 diff --git a/libs/apnos/apnos.py b/libs/apnos/apnos.py index 89352fd37..84b20888f 100644 --- a/libs/apnos/apnos.py +++ b/libs/apnos/apnos.py @@ -15,6 +15,7 @@ from scp import SCPClient import os import allure + class APNOS: def __init__(self, credentials=None, pwd=os.getcwd()): diff --git a/libs/controller/controller.py b/libs/controller/controller.py index 1b72bcfa0..34339cc4e 100644 --- a/libs/controller/controller.py +++ b/libs/controller/controller.py @@ -17,6 +17,7 @@ import swagger_client from swagger_client import FirmwareManagementApi from swagger_client import EquipmentGatewayApi from bs4 import BeautifulSoup +import threading class ConfigureController: @@ -75,31 +76,34 @@ class Controller(ConfigureController): if customer_id is None: self.customer_id = 2 print("Setting to default Customer ID 2") - + # # Setting the Controller Client Configuration self.select_controller_data(controller_data=controller_data) self.set_credentials(controller_data=controller_data) - # self.configuration.refresh_api_key_hook = self.get_bearer_token + self.configuration.refresh_api_key_hook = self.get_bearer_token # Connecting to Controller self.api_client = swagger_client.ApiClient(self.configuration) self.login_client = swagger_client.LoginApi(api_client=self.api_client) - self.bearer = self.get_bearer_token() + self.bearer = False + self.disconnect = False + self.semaphore = False + try: + self.bearer = self.get_bearer_token() + # t1 = threading.Thread(target=self.refresh_instance) + # t1.start() + self.api_client.default_headers['Authorization'] = "Bearer " + self.bearer._access_token + self.status_client = swagger_client.StatusApi(api_client=self.api_client) + self.equipment_client = swagger_client.EquipmentApi(self.api_client) + self.profile_client = swagger_client.ProfileApi(self.api_client) + self.api_client.configuration.api_key_prefix = { + "Authorization": "Bearer " + self.bearer._access_token + } + self.api_client.configuration.refresh_api_key_hook = self.refresh_instance + except Exception as e: + self.bearer = False + print(e) - self.api_client.default_headers['Authorization'] = "Bearer " + self.bearer._access_token - self.status_client = swagger_client.StatusApi(api_client=self.api_client) - self.equipment_client = swagger_client.EquipmentApi(self.api_client) - self.profile_client = swagger_client.ProfileApi(self.api_client) - self.api_client.configuration.api_key_prefix = { - "Authorization": "Bearer " + self.bearer._access_token - } - self.api_client.configuration.refresh_api_key_hook = self.refresh_instance - self.ping_response = self.portal_ping() - self.default_profiles = {} - # print(self.bearer) - if self.ping_response._application_name != 'PortalServer': - print("Server not Reachable") - exit() print("Connected to Controller Server") def get_bearer_token(self): @@ -111,6 +115,15 @@ class Controller(ConfigureController): def refresh_instance(self): # Connecting to Controller + # while True: + # print("Controller Refresh Thread Started") + # for i in range(0, 800): + # if self.disconnect: + # break + # time.sleep(1) + # if self.disconnect: + # break + # self.semaphore = True self.api_client = swagger_client.ApiClient(self.configuration) self.login_client = swagger_client.LoginApi(api_client=self.api_client) self.bearer = self.get_bearer_token() @@ -130,11 +143,13 @@ class Controller(ConfigureController): print("Server not Reachable") exit() print("Connected to Controller Server") + # self.semaphore = False def portal_ping(self): return self.login_client.portal_ping() def disconnect_Controller(self): + self.disconnect = True self.api_client.__del__() # Returns a List of All the Equipments that are available in the cloud instances @@ -837,16 +852,21 @@ class FirmwareUtility(JFrogUtility): firmware_version = False print("firmware not available: ", firmware_version) return firmware_version -controller = { - 'url': "https://wlan-portal-svc-nola-ext-03.cicd.lab.wlan.tip.build", # API base url for the controller - 'username': 'support@example.com', - 'password': 'support', - 'version': "1.1.0-SNAPSHOT", - 'commit_date': "2021-04-27" -} -api = Controller(controller_data=controller) -for i in range(0, 2500): - print(i) - time.sleep(1) -print(api.get_equipment_by_customer_id()) -api.disconnect_Controller() \ No newline at end of file + +# controller = { +# 'url': "https://wlan-portal-svc-nola-ext-03.cicd.lab.wlan.tip.build", # API base url for the controller +# 'username': 'support@example.com', +# 'password': 'support', +# 'version': "1.1.0-SNAPSHOT", +# 'commit_date': "2021-04-27" +# } +# api = Controller(controller_data=controller) +# # profile = ProfileUtility(sdk_client=api) +# # profile.cleanup_profiles() +# # # print(api.get_equipment_by_customer_id()) +# # # +# for i in range(0, 300): +# print(i) +# time.sleep(1) +# print(api.get_equipment_by_customer_id()) +# api.disconnect_Controller() diff --git a/libs/lanforge/lf_tests.py b/libs/lanforge/lf_tests.py index b7792c8f2..1286c747e 100644 --- a/libs/lanforge/lf_tests.py +++ b/libs/lanforge/lf_tests.py @@ -4,34 +4,50 @@ ######################################################################################################### from sta_connect2 import StaConnect2 +import time +from eap_connect import EAPConnect class RunTest: - def __init__(self, lanforge_ip, lanforge_port, lanforge_prefix): - self.lanforge_ip = lanforge_ip - self.lanforge_port = lanforge_port - self.lanforge_prefix = lanforge_prefix + def __init__(self, lanforge_data=None, debug=False): + self.lanforge_ip = lanforge_data["ip"] + self.lanforge_port = lanforge_data["port"] + self.twog_radios = lanforge_data["2.4G-Radio"] + self.fiveg_radios = lanforge_data["5G-Radio"] + self.ax_radios = lanforge_data["AX-Radio"] + self.upstream_port = lanforge_data["upstream"] + self.twog_prefix = lanforge_data["2.4G-Station-Name"] + self.fiveg_prefix = lanforge_data["5G-Station-Name"] + self.ax_prefix = lanforge_data["AX-Station-Name"] + self.staConnect = StaConnect2(self.lanforge_ip, self.lanforge_port, debug_=debug) - def Single_Client_Connectivity(self, upstream_port="eth1", radio="wiphy0", ssid="TestAP", passkey="ssid_psk", - security="open", - station_name="sta0000", test_case=None, rid=None, client=None, logger=None): + def Client_Connectivity(self, ssid="[BLANK]", passkey="[BLANK]", security="open", station_name=[], + mode="BRIDGE", vlan_id=1, band="twog"): '''SINGLE CLIENT CONNECTIVITY using test_connect2.py''' - self.staConnect = StaConnect2(self.lanforge_ip, self.lanforge_port, debug_=False) self.staConnect.sta_mode = 0 self.staConnect.upstream_resource = 1 - self.staConnect.upstream_port = upstream_port - self.staConnect.radio = radio + if mode == "BRIDGE": + self.staConnect.upstream_port = self.upstream_port + elif mode == "NAT": + self.staConnect.upstream_port = self.upstream_port + else: + self.staConnect.upstream_port = self.upstream_port + "." + str(vlan_id) + if band == "twog": + self.staConnect.radio = self.twog_radios[0] + self.staConnect.sta_prefix = self.twog_prefix + if band == "fiveg": + self.staConnect.radio = self.fiveg_radios[0] + self.staConnect.sta_prefix = self.fiveg_prefix self.staConnect.resource = 1 self.staConnect.dut_ssid = ssid self.staConnect.dut_passwd = passkey self.staConnect.dut_security = security self.staConnect.station_names = station_name - self.staConnect.sta_prefix = self.lanforge_prefix - self.staConnect.runtime_secs = 10 + self.staConnect.runtime_secs = 40 self.staConnect.bringup_time_sec = 60 self.staConnect.cleanup_on_exit = True - # staConnect.cleanup() + # self.staConnect.cleanup() self.staConnect.setup() self.staConnect.start() print("napping %f sec" % self.staConnect.runtime_secs) @@ -41,18 +57,15 @@ class RunTest: run_results = self.staConnect.get_result_list() for result in run_results: print("test result: " + result) - # result = 'pass' - print("Single Client Connectivity :", self.staConnect.passes) - if self.staConnect.passes() == True: - print("Single client connection to", self.staConnect.dut_ssid, "successful. Test Passed") - client.update_testrail(case_id=test_case, run_id=rid, status_id=1, msg='Client connectivity passed') - logger.info("Client connectivity to " + self.staConnect.dut_ssid + " Passed") - return ("passed") + result = True + print("Client Connectivity :", self.staConnect.passes) + if self.staConnect.passes(): + print("client connection to", self.staConnect.dut_ssid, "successful. Test Passed") else: - client.update_testrail(case_id=test_case, run_id=rid, status_id=5, msg='Client connectivity failed') - print("Single client connection to", self.staConnect.dut_ssid, "unsuccessful. Test Failed") - logger.warning("Client connectivity to " + self.staConnect.dut_ssid + " FAILED") - return ("failed") + print("client connection to", self.staConnect.dut_ssid, "unsuccessful. Test Failed") + result = False + time.sleep(3) + return self.staConnect.passes(), result def Single_Client_EAP(self, port, sta_list, ssid_name, radio, security, eap_type, identity, ttls_password, test_case, rid, client, logger): @@ -68,7 +81,7 @@ class RunTest: eap_connect.eap = eap_type eap_connect.identity = identity eap_connect.ttls_passwd = ttls_password - eap_connect.runtime_secs = 10 + eap_connect.runtime_secs = 40 eap_connect.setup() eap_connect.start() print("napping %f sec" % eap_connect.runtime_secs) @@ -78,21 +91,11 @@ class RunTest: run_results = eap_connect.get_result_list() for result in run_results: print("test result: " + result) - # result = 'pass' + result = True print("Single Client Connectivity :", eap_connect.passes) - if eap_connect.passes() == True: + if eap_connect.passes(): print("Single client connection to", ssid_name, "successful. Test Passed") - client.update_testrail(case_id=test_case, run_id=rid, status_id=1, msg='Client connectivity passed') - logger.info("Client connectivity to " + ssid_name + " Passed") - return ("passed") else: - client.update_testrail(case_id=test_case, run_id=rid, status_id=5, msg='Client connectivity failed') print("Single client connection to", ssid_name, "unsuccessful. Test Failed") - logger.warning("Client connectivity to " + ssid_name + " FAILED") - return ("failed") - - def testrail_retest(self, test_case, rid, ssid_name, client, logger): - client.update_testrail(case_id=test_case, run_id=rid, status_id=4, - msg='Error in Client Connectivity Test. Needs to be Re-run') - print("Error in test for single client connection to", ssid_name) - logger.warning("ERROR testing Client connectivity to " + ssid_name) + result = False + return self.staConnect.passes(), result diff --git a/tests/configuration.py b/tests/configuration.py index 34332b49d..a6e7d2ff2 100644 --- a/tests/configuration.py +++ b/tests/configuration.py @@ -1,17 +1,90 @@ - CONFIGURATION = { - "ext-03": { + "basic-ext-03-01": { "controller": { 'url': "https://wlan-portal-svc-nola-ext-03.cicd.lab.wlan.tip.build", # API base url for the controller 'username': 'support@example.com', 'password': 'support', - 'version': '1.0.0-SNAPSHOT', - 'commit_date': '2021-03-01' + 'version': "1.1.0-SNAPSHOT", + 'commit_date': "2021-04-27" }, 'access_point': [ { 'model': 'ecw5410', - 'mode' : "wifi5", + 'mode': "wifi5", + 'serial': '903cb3944807', + 'jumphost': True, + 'ip': "192.168.200.230", + 'username': "lanforge", + 'password': "lanforge", + 'port': 22, + 'jumphost_tty': '/dev/ttyAP1', + 'version': "ecw5410-2021-03-30-pending-9cb289b" + } + ], + "traffic_generator": { + "name": "lanforge", + "details": { + "ip": "localhost", + "port": 8080, + "2.4G-Radio": ["wiphy0"], + "5G-Radio": ["wiphy1"], + "AX-Radio": ["wiphy2"], + "upstream": "eth1", + "2.4G-Station-Name": "wlan0", + "5G-Station-Name": "wlan1", + "AX-Station-Name": "ax", + } + } + }, + "basic-ext-03-02": { + "controller": { + 'url': "https://wlan-portal-svc-nola-ext-03.cicd.lab.wlan.tip.build", # API base url for the controller + 'username': 'support@example.com', + 'password': 'support', + 'version': "1.1.0-SNAPSHOT", + 'commit_date': "2021-04-27" + }, + 'access_point': [ + { + 'model': 'ecw5410', + 'mode': 'wifi5', + 'serial': '903cb394486f', + 'jumphost': True, + 'ip': "192.168.200.233", + 'username': "lanforge", + 'password': "lanforge", + 'port': 22, + 'jumphost_tty': '/dev/ttyAP1', + 'version': "ecw5410-2021-04-26-pending-3fc41fa" + } + ], + "traffic_generator": { + "name": "lanforge", + "details": { + "ip": "192.168.200.233", + "port": 8080, + "2.4G-Radio": ["wiphy0"], + "5G-Radio": ["wiphy1"], + "AX-Radio": ["wiphy2"], + "upstream": "eth1", + "2.4G-Station-Name": "wlan0", + "5G-Station-Name": "wlan1", + "AX-Station-Name": "ax", + } + } + }, + "basic-ext-03-03": { + "controller": { + 'url': "https://wlan-portal-svc-nola-ext-03.cicd.lab.wlan.tip.build", # API base url for the controller + 'username': 'support@example.com', + 'password': 'support', + 'version': "1.1.0-SNAPSHOT", + 'commit_date': "2021-04-27" + }, + 'access_point': [ + { + 'model': 'ecw5410', + 'mode': 'wifi5', 'serial': '903cb3944857', 'jumphost': True, 'ip': "192.168.200.80", @@ -22,7 +95,7 @@ CONFIGURATION = { 'version': "ecw5410-2021-04-26-pending-3fc41fa" } ], - "traffic_generator": { + "traffic_generator": { "name": "lanforge", "details": { "ip": "192.168.200.80", @@ -32,90 +105,13 @@ CONFIGURATION = { "AX-Radio": ["wiphy2"], "upstream": "eth1", "2.4G-Station-Name": "wlan0", - "5G-Station-Name": "wlan1", + "5G-Station-Name": "wlan0", "AX-Station-Name": "ax", } } }, - "ext-04": { - "controller": { - 'url': "https://wlan-portal-svc-nola-ext-04.cicd.lab.wlan.tip.build", # API base url for the controller - 'username': 'support@example.com', - 'password': 'support', - 'version': '1.0.0-SNAPSHOT', - 'commit_date': '2021-03-01' - }, - 'access_point': [ - { - 'model': 'ecw5410', - 'mode': 'wifi5', - 'serial': '903cb394486f', - 'jumphost': True, - 'ip': "192.168.200.81", - 'username': "lanforge", - 'password': "lanforge", - 'port': 22, - 'jumphost_tty': '/dev/ttyAP1', - 'version': "ecw5410-2021-04-26-pending-3fc41fa" - } - ], - "traffic_generator": { - "name": "lanforge", - "details": { - "ip": "192.168.200.81", - "port": 8080, - "2.4G-Radio": ["wiphy0"], - "5G-Radio": ["wiphy1"], - "AX-Radio": ["wiphy2"], - "upstream": "eth1", - "2.4G-Station-Name": "wlan0", - "5G-Station-Name": "wlan1", - "AX-Station-Name": "ax", - } - } - }, - "ext-05": { - "controller": { - 'url': "https://wlan-portal-svc-nola-ext-04.cicd.lab.wlan.tip.build", # API base url for the controller - 'username': 'support@example.com', - 'password': 'support', - 'version': '1.0.0-SNAPSHOT', - 'commit_date': '2021-03-01' - }, - 'access_point': [ - { - 'model': 'ecw5410', - 'mode': 'wifi5', - 'serial': '903cb3944817', - 'jumphost': True, - 'ip': "192.168.200.82", - 'username': "lanforge", - 'password': "lanforge", - 'port': 22, - 'jumphost_tty': '/dev/ttyAP1', - 'version': "ecw5410-2021-04-26-pending-3fc41fa" - } - ], - "traffic_generator": { - "name": "lanforge", - "details": { - "ip": "192.168.200.82", - "port": 8080, - "2.4G-Radio": ["wiphy0"], - "5G-Radio": ["wiphy1"], - "AX-Radio": ["wiphy2"], - "upstream": "eth1", - "2.4G-Station-Name": "wlan0", - "5G-Station-Name": "wlan1", - "AX-Station-Name": "ax", - } - } - } - } - - FIRMWARE = { # jFrog parameters "JFROG": @@ -130,7 +126,7 @@ FIRMWARE = { } RADIUS_SERVER_DATA = { - "ip": "192.168.200.75", + "ip": "10.28.3.100", "port": 1812, "secret": "testing123", "user": "nolaradius", diff --git a/tests/conftest.py b/tests/conftest.py index e683dfe37..c0e3ae308 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -92,6 +92,17 @@ Test session base fixture """ +# To be depreciated as testrails will go +@pytest.fixture(scope="session") +def test_cases(): + yield TEST_CASES + + +@pytest.fixture(scope="session") +def instantiate_jFrog(): + yield FIRMWARE["JFROG"] + + @pytest.fixture(scope="session") def testbed(request): var = request.config.getoption("--testbed") @@ -129,9 +140,25 @@ def get_apnos(): yield APNOS +# APNOS SETUP +@pytest.fixture(scope="session") +def instantiate_access_point(testbed, get_apnos, get_configuration): + # Used to add openwrtctl.py in case of serial console mode + for access_point_info in get_configuration['access_point']: + if access_point_info["jumphost"]: + allure.attach(name="added openwrtctl.py to :", + body=access_point_info['ip'] + ":" + str(access_point_info["port"])) + get_apnos(access_point_info, pwd="../libs/apnos/") + else: + allure.attach(name="Direct AP SSH : ", + body=access_point_info['ip'] + ":" + str(access_point_info["port"])) + # Write a code to verify Access Point Connectivity + yield True + + # Controller Fixture @pytest.fixture(scope="session") -def setup_controller(request, get_configuration): +def setup_controller(request, get_configuration, instantiate_access_point): try: sdk_client = Controller(controller_data=get_configuration["controller"]) allure.attach(body=str(get_configuration["controller"]), name="Controller Instantiated: ") @@ -149,11 +176,11 @@ def setup_controller(request, get_configuration): yield sdk_client -@pytest.fixture(scope="session") -def instantiate_firmware(controller_instance, instantiate_jFrog, get_configuration): +@pytest.fixture(scope="class") +def instantiate_firmware(setup_controller, instantiate_jFrog, get_configuration): firmware_client_obj = [] for access_point_info in get_configuration['access_point']: - firmware_client = FirmwareUtility(jfrog_credentials=instantiate_jFrog, sdk_client=controller_instance, + firmware_client = FirmwareUtility(jfrog_credentials=instantiate_jFrog, sdk_client=setup_controller, model=access_point_info["model"], version=access_point_info["version"]) firmware_client_obj.append(firmware_client) @@ -166,7 +193,7 @@ Instantiate Reporting @pytest.fixture(scope="session") -def instantiate_reporting(request, testbed, get_latest_firmware): +def update_report(request, testbed, get_configuration): if request.config.getoption("--skip-testrail"): tr_client = Reporting() else: @@ -177,7 +204,7 @@ def instantiate_reporting(request, testbed, get_latest_firmware): else: projId = tr_client.get_project_id(project_name=request.config.getini("tr_project_id")) test_run_name = request.config.getini("tr_prefix") + testbed + "_" + str( - datetime.date.today()) + "_" + get_latest_firmware + datetime.date.today()) + "_" + get_configuration['access_point'][0]['version'] tr_client.create_testrun(name=test_run_name, case_ids=list(TEST_CASES.values()), project_id=projId, milestone_id=request.config.getini("milestone"), description="Automated Nightly Sanity test run for new firmware build") @@ -186,78 +213,15 @@ def instantiate_reporting(request, testbed, get_latest_firmware): yield tr_client -@pytest.fixture(scope="session") -def instantiate_jFrog(): - yield FIRMWARE["JFROG"] +""" +FRAMEWORK MARKER LOGIC - -@pytest.fixture(scope="session") -def check_lanforge_connectivity(testbed): - # Check port - yield True - - -@pytest.fixture(scope="session") -def setup_perfecto_devices(request): - yield True - - -@pytest.fixture(scope="session") -def test_cases(): - yield TEST_CASES - - -@pytest.fixture(scope="session") -def instantiate_access_point(testbed): - APNOS(CONFIGURATION[testbed]['access_point'][0], pwd="../libs/apnos/") - yield True - - -@pytest.fixture(scope="function") -def test_access_point(testbed, instantiate_access_point): - ap_ssh = APNOS(CONFIGURATION[testbed]['access_point'][0]) - ap_ssh.reboot() - time.sleep(100) - status = ap_ssh.get_manager_state() - if "ACTIVE" not in status: - time.sleep(30) - ap_ssh = APNOS(CONFIGURATION[testbed]['access_point'][0]) - status = ap_ssh.get_manager_state() - yield status - - -@pytest.fixture(scope="session") -def setup_profile_data(testbed): - model = CONFIGURATION[testbed]["access_point"][0]["model"] - profile_data = {} - for mode in "BRIDGE", "NAT", "VLAN": - profile_data[mode] = {} - for security in "OPEN", "WPA", "WPA2_P", "WPA2_E", "WEP": - profile_data[mode][security] = {} - for radio in "2G", "5G": - profile_data[mode][security][radio] = {} - name_string = f"{'Sanity'}-{testbed}-{model}-{radio}_{security}_{mode}" - ssid_name = f"{'Sanity'}-{model}-{radio}_{security}_{mode}" - passkey_string = f"{radio}-{security}_{mode}" - profile_data[mode][security][radio]["profile_name"] = name_string - profile_data[mode][security][radio]["ssid_name"] = ssid_name - if mode == "VLAN": - profile_data[mode][security][radio]["vlan"] = 100 - else: - profile_data[mode][security][radio]["vlan"] = 1 - if mode != "NAT": - profile_data[mode][security][radio]["mode"] = "BRIDGE" - else: - profile_data[mode][security][radio]["mode"] = "NAT" - if security != "OPEN": - profile_data[mode][security][radio]["security_key"] = passkey_string - else: - profile_data[mode][security][radio]["security_key"] = "[BLANK]" - yield profile_data +""" @pytest.fixture(scope="session") def get_security_flags(): + # Add more classifications as we go security = ["open", "wpa", "wpa2_personal", "wpa2_enterprise", "wpa3_enterprise", "twog", "fiveg", "radius"] yield security @@ -282,28 +246,43 @@ def get_markers(request, get_security_flags): yield security_dict -@pytest.fixture(scope="session") -def get_latest_firmware(instantiate_firmware): - try: - latest_firmware = instantiate_firmware.get_fw_version() - except Exception as e: - print(e) - latest_firmware = False - yield latest_firmware - - +# Will be availabe as a test case @pytest.fixture(scope="function") -def check_ap_firmware_ssh(testbed): - try: - ap_ssh = APNOS(CONFIGURATION[testbed]['access_point'][0]) - active_fw = ap_ssh.get_active_firmware() - print(active_fw) - except Exception as e: - print(e) - active_fw = False - yield active_fw +def test_access_point(testbed, get_apnos, get_configuration): + mgr_status = [] + for access_point_info in get_configuration['access_point']: + ap_ssh = get_apnos(access_point_info) + ap_ssh.reboot() + time.sleep(100) + status = ap_ssh.get_manager_state() + if "ACTIVE" not in status: + time.sleep(30) + ap_ssh = APNOS(access_point_info) + status = ap_ssh.get_manager_state() + mgr_status.append(status) + yield mgr_status @pytest.fixture(scope="session") def client_connectivity(): yield StaConnect2 + + +@pytest.fixture(scope="session") +def get_lanforge_data(get_configuration): + lanforge_data = {} + if get_configuration['traffic_generator']['name'] == 'lanforge': + lanforge_data = { + "lanforge_ip": get_configuration['traffic_generator']['details']['ip'], + "lanforge-port-number": get_configuration['traffic_generator']['details']['port'], + "lanforge_2dot4g": get_configuration['traffic_generator']['details']['2.4G-Radio'][0], + "lanforge_5g": get_configuration['traffic_generator']['details']['5G-Radio'][0], + "lanforge_2dot4g_prefix": get_configuration['traffic_generator']['details']['2.4G-Station-Name'], + "lanforge_5g_prefix": get_configuration['traffic_generator']['details']['5G-Station-Name'], + "lanforge_2dot4g_station": get_configuration['traffic_generator']['details']['2.4G-Station-Name'], + "lanforge_5g_station": get_configuration['traffic_generator']['details']['5G-Station-Name'], + "lanforge_bridge_port": get_configuration['traffic_generator']['details']['upstream'], + "lanforge_vlan_port": get_configuration['traffic_generator']['details']['upstream'] + ".100", + "vlan": 100 + } + yield lanforge_data diff --git a/tests/e2e/basic/air_time_fairness_test/__init__.py b/tests/e2e/advanced/air_time_fairness_test/__init__.py similarity index 100% rename from tests/e2e/basic/air_time_fairness_test/__init__.py rename to tests/e2e/advanced/air_time_fairness_test/__init__.py diff --git a/tests/e2e/basic/_basic_test_setup/setup__e2e_resources.py b/tests/e2e/basic/_basic_test_setup/setup__e2e_resources.py index 8af8183d6..6a3a1e554 100644 --- a/tests/e2e/basic/_basic_test_setup/setup__e2e_resources.py +++ b/tests/e2e/basic/_basic_test_setup/setup__e2e_resources.py @@ -1,81 +1,81 @@ -""" - Test Case Module: setup test cases for basic test cases - Details: Firmware Upgrade - -""" -import pytest - -@pytest.mark.configure_lanforge -def test_configure_lanforge(configure_lanforge): - - assert True - - -@pytest.mark.sanity -@pytest.mark.bridge -@pytest.mark.nat -@pytest.mark.vlan -@pytest.mark.firmware -class TestFirmware(object): - - @pytest.mark.firmware_create - def test_firmware_create(self, upload_firmware, instantiate_testrail, instantiate_project, test_cases): - if upload_firmware != 0: - instantiate_testrail.update_testrail(case_id=test_cases["create_fw"], run_id=instantiate_project, - status_id=1, - msg='Create new FW version by API successful') - PASS = True - else: - instantiate_testrail.update_testrail(case_id=test_cases["create_fw"], run_id=instantiate_project, - status_id=5, - msg='Error creating new FW version by API') - PASS = False - assert PASS - - @pytest.mark.firmware_upgrade - def test_firmware_upgrade_request(self, upgrade_firmware, instantiate_testrail, instantiate_project, test_cases): - print() - if not upgrade_firmware: - instantiate_testrail.update_testrail(case_id=test_cases["upgrade_api"], run_id=instantiate_project, - status_id=0, - msg='Error requesting upgrade via API') - PASS = False - else: - instantiate_testrail.update_testrail(case_id=test_cases["upgrade_api"], run_id=instantiate_project, - status_id=1, - msg='Upgrade request using API successful') - PASS = True - assert PASS - - @pytest.mark.check_active_firmware_cloud - def test_active_version_cloud(self, get_latest_firmware, check_ap_firmware_cloud, instantiate_testrail, - instantiate_project, test_cases): - if get_latest_firmware != check_ap_firmware_cloud: - instantiate_testrail.update_testrail(case_id=test_cases["cloud_fw"], run_id=instantiate_project, - status_id=5, - msg='CLOUDSDK reporting incorrect firmware version.') - else: - instantiate_testrail.update_testrail(case_id=test_cases["cloud_fw"], run_id=instantiate_project, - status_id=1, - msg='CLOUDSDK reporting correct firmware version.') - - assert get_latest_firmware == check_ap_firmware_cloud - - -@pytest.mark.sanity -@pytest.mark.bridge -@pytest.mark.nat -@pytest.mark.vlan -@pytest.mark.check_active_firmware_ap -def test_ap_firmware(check_ap_firmware_ssh, get_latest_firmware, instantiate_testrail, instantiate_project, - test_cases): - if check_ap_firmware_ssh == get_latest_firmware: - instantiate_testrail.update_testrail(case_id=test_cases["ap_upgrade"], run_id=instantiate_project, - status_id=1, - msg='Upgrade to ' + get_latest_firmware + ' successful') - else: - instantiate_testrail.update_testrail(case_id=test_cases["ap_upgrade"], run_id=instantiate_project, - status_id=4, - msg='Cannot reach AP after upgrade to check CLI - re-test required') - - assert check_ap_firmware_ssh == get_latest_firmware +# """ +# Test Case Module: setup test cases for basic test cases +# Details: Firmware Upgrade +# +# """ +# import pytest +# +# @pytest.mark.configure_lanforge +# def test_configure_lanforge(configure_lanforge): +# +# assert True +# +# +# @pytest.mark.sanity +# @pytest.mark.bridge +# @pytest.mark.nat +# @pytest.mark.vlan +# @pytest.mark.firmware +# class TestFirmware(object): +# +# @pytest.mark.firmware_create +# def test_firmware_create(self, upload_firmware, instantiate_testrail, instantiate_project, test_cases): +# if upload_firmware != 0: +# instantiate_testrail.update_testrail(case_id=test_cases["create_fw"], run_id=instantiate_project, +# status_id=1, +# msg='Create new FW version by API successful') +# PASS = True +# else: +# instantiate_testrail.update_testrail(case_id=test_cases["create_fw"], run_id=instantiate_project, +# status_id=5, +# msg='Error creating new FW version by API') +# PASS = False +# assert PASS +# +# @pytest.mark.firmware_upgrade +# def test_firmware_upgrade_request(self, upgrade_firmware, instantiate_testrail, instantiate_project, test_cases): +# print() +# if not upgrade_firmware: +# instantiate_testrail.update_testrail(case_id=test_cases["upgrade_api"], run_id=instantiate_project, +# status_id=0, +# msg='Error requesting upgrade via API') +# PASS = False +# else: +# instantiate_testrail.update_testrail(case_id=test_cases["upgrade_api"], run_id=instantiate_project, +# status_id=1, +# msg='Upgrade request using API successful') +# PASS = True +# assert PASS +# +# @pytest.mark.check_active_firmware_cloud +# def test_active_version_cloud(self, get_latest_firmware, check_ap_firmware_cloud, instantiate_testrail, +# instantiate_project, test_cases): +# if get_latest_firmware != check_ap_firmware_cloud: +# instantiate_testrail.update_testrail(case_id=test_cases["cloud_fw"], run_id=instantiate_project, +# status_id=5, +# msg='CLOUDSDK reporting incorrect firmware version.') +# else: +# instantiate_testrail.update_testrail(case_id=test_cases["cloud_fw"], run_id=instantiate_project, +# status_id=1, +# msg='CLOUDSDK reporting correct firmware version.') +# +# assert get_latest_firmware == check_ap_firmware_cloud +# +# +# @pytest.mark.sanity +# @pytest.mark.bridge +# @pytest.mark.nat +# @pytest.mark.vlan +# @pytest.mark.check_active_firmware_ap +# def test_ap_firmware(check_ap_firmware_ssh, get_latest_firmware, instantiate_testrail, instantiate_project, +# test_cases): +# if check_ap_firmware_ssh == get_latest_firmware: +# instantiate_testrail.update_testrail(case_id=test_cases["ap_upgrade"], run_id=instantiate_project, +# status_id=1, +# msg='Upgrade to ' + get_latest_firmware + ' successful') +# else: +# instantiate_testrail.update_testrail(case_id=test_cases["ap_upgrade"], run_id=instantiate_project, +# status_id=4, +# msg='Cannot reach AP after upgrade to check CLI - re-test required') +# +# assert check_ap_firmware_ssh == get_latest_firmware diff --git a/tests/e2e/basic/client_connectivity_test/bridge/basic_security_modes/test__configuration_basic_modes.py b/tests/e2e/basic/client_connectivity_test/bridge/basic_security_modes/test__configuration_basic_modes.py deleted file mode 100644 index d9b969a83..000000000 --- a/tests/e2e/basic/client_connectivity_test/bridge/basic_security_modes/test__configuration_basic_modes.py +++ /dev/null @@ -1,91 +0,0 @@ -import pytest -import allure - -pytestmark = [pytest.mark.client_connectivity, pytest.mark.bridge, pytest.mark.configuration, pytest.mark.basic] - -setup_params_general = { - "mode": "BRIDGE", - "ssid_modes": { - "open": [{"ssid_name": "ssid_open_2g", "appliedRadios": ["is2dot4GHz"]}, - {"ssid_name": "ssid_open_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], - "wpa": [{"ssid_name": "ssid_wpa_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}], - "wpa2_personal": [ - {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}]}, - "rf": {}, - "radius": False -} - - -@allure.feature("BRIDGE MODE CLIENT CONNECTIVITY") -@pytest.mark.parametrize( - 'setup_client_connectivity', - [setup_params_general], - indirect=True, - scope="package" -) -@pytest.mark.usefixtures("setup_client_connectivity") -class TestBridgeModeConfiguration(object): - - @pytest.mark.open - @pytest.mark.twog - @allure.story('open 2.4 GHZ Band') - def test_open_ssid_2g_config(self, setup_client_connectivity): - allure.attach(str(setup_client_connectivity["open_2g"]), 'OPEN SSID 2.4 GHz Creation : ') - assert setup_client_connectivity["open_2g"] - - @pytest.mark.open - @pytest.mark.fiveg - @allure.story('open 5 GHZ Band') - def test_open_ssid_5g_config(self, setup_client_connectivity): - allure.attach(str(setup_client_connectivity["open_5g"]), 'OPEN SSID 5 GHz Creation : ') - assert setup_client_connectivity["open_5g"] - - @pytest.mark.wpa - @pytest.mark.twog - @allure.story('wpa 2.4 GHZ Band') - def test_wpa_ssid_2g_config(self, setup_client_connectivity): - print(setup_client_connectivity) - allure.attach(str(setup_client_connectivity["wpa_2g"]), 'WPA SSID 2.4 GHz Creation : ') - assert setup_client_connectivity["wpa_2g"] - - @pytest.mark.wpa - @pytest.mark.fiveg - @allure.story('wpa 5 GHZ Band') - def test_wpa_ssid_5g_config(self, setup_client_connectivity): - allure.attach(str(setup_client_connectivity["wpa_5g"]), 'WPA SSID 5 GHz Creation : ') - assert setup_client_connectivity["wpa_5g"] - - @pytest.mark.wpa2_personal - @pytest.mark.twog - @allure.story('wpa2_personal 2.4 GHZ Band') - def test_wpa2_personal_ssid_2g_config(self, setup_client_connectivity): - allure.attach(str(setup_client_connectivity["wpa2_personal_2g"]), 'WPA2 Personal SSID 2.4 GHz Creation : ') - assert setup_client_connectivity["wpa2_personal_2g"] - - @pytest.mark.wpa2_personal - @pytest.mark.fiveg - @allure.story('wpa2_personal 5 GHZ Band') - def test_wpa2_personal_ssid_5g_config(self, setup_client_connectivity): - allure.attach(str(setup_client_connectivity["wpa2_personal_5g"]), 'WPA2 Personal SSID 5 GHz Creation : ') - assert setup_client_connectivity["wpa2_personal_5g"] - - @allure.story('equipment AP Configuration') - def test_equipment_ap_profile_configuration(self, setup_client_connectivity): - allure.attach(str(setup_client_connectivity["equipment_ap"]), 'Equipment AP Profile Creation : ') - assert setup_client_connectivity["equipment_ap"] - - @allure.story('Config push from controller to AP') - def test_verify_vif_config(self, setup_client_connectivity): - allure.attach(str(setup_client_connectivity["vifc"]), 'Profile Push from Controller to AP : ') - assert setup_client_connectivity["vifc"] - - @allure.story('Config in VIF State') - def test_verify_vif_state(self, setup_client_connectivity): - allure.attach(str(setup_client_connectivity["vifs"]), 'VIF CONFIG AND VIF STATE ARE SAME : ') - assert setup_client_connectivity["vifs"] - - diff --git a/tests/e2e/basic/client_connectivity_test/bridge/basic_security_modes/test_basic_security.py b/tests/e2e/basic/client_connectivity_test/bridge/basic_security_modes/test_basic_security.py deleted file mode 100644 index a0c86694f..000000000 --- a/tests/e2e/basic/client_connectivity_test/bridge/basic_security_modes/test_basic_security.py +++ /dev/null @@ -1,124 +0,0 @@ -import time - -import pytest -import allure - -pytestmark = [pytest.mark.client_connectivity, pytest.mark.bridge, pytest.mark.basic] - -setup_params_general = { - "mode": "BRIDGE", - "ssid_modes": { - "open": [{"ssid_name": "ssid_open_2g", "appliedRadios": ["is2dot4GHz"]}, - {"ssid_name": "ssid_open_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], - "wpa": [{"ssid_name": "ssid_wpa_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}], - "wpa2_personal": [ - {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}]}, - "rf": {}, - "radius": False -} - - -@allure.feature("BRIDGE MODE CLIENT CONNECTIVITY") -@pytest.mark.parametrize( - 'setup_client_connectivity', - [setup_params_general], - indirect=True, - scope="package" -) -@pytest.mark.usefixtures("setup_client_connectivity") -class TestBridgeModeConnectivity(object): - - @pytest.mark.open - @pytest.mark.twog - @allure.story('open 2.4 GHZ Band') - def test_open_ssid_2g(self): - ssid_data = setup_params_general["ssid_modes"]["open"][0] - print(ssid_data) - assert "setup_client_connectivity" - - @pytest.mark.open - @pytest.mark.fiveg - @allure.story('open 5 GHZ Band') - def test_open_ssid_5g(self): - ssid_data = setup_params_general["ssid_modes"]["open"][1] - print(ssid_data) - assert "setup_client_connectivity" - - @pytest.mark.wpa - @pytest.mark.twog - @allure.story('wpa 2.4 GHZ Band') - def test_wpa_ssid_2g(self, request, get_lanforge_data, instantiate_project, instantiate_testrail, - client_connectivity, test_cases): - profile_data = setup_params_general["ssid_modes"]["wpa"][0] - print(profile_data) - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) - print(profile_data, get_lanforge_data) - staConnect = client_connectivity(get_lanforge_data["lanforge_ip"], - int(get_lanforge_data["lanforge-port-number"]), - debug_=False) - staConnect.sta_mode = 0 - staConnect.upstream_resource = 1 - staConnect.upstream_port = get_lanforge_data["lanforge_bridge_port"] - staConnect.radio = get_lanforge_data["lanforge_2dot4g"] - staConnect.resource = 1 - staConnect.dut_ssid = profile_data["ssid_name"] - staConnect.dut_passwd = profile_data["security_key"] - staConnect.dut_security = "wpa" - staConnect.station_names = station_names - staConnect.sta_prefix = get_lanforge_data["lanforge_2dot4g_prefix"] - staConnect.runtime_secs = 10 - staConnect.bringup_time_sec = 60 - staConnect.cleanup_on_exit = True - # staConnect.cleanup() - staConnect.setup() - staConnect.start() - print("napping %f sec" % staConnect.runtime_secs) - time.sleep(staConnect.runtime_secs) - staConnect.stop() - staConnect.cleanup() - run_results = staConnect.get_result_list() - for result in run_results: - print("test result: " + result) - # result = 'pass' - print("Single Client Connectivity :", staConnect.passes) - if staConnect.passes(): - instantiate_testrail.update_testrail(case_id=test_cases["2g_wpa_bridge"], run_id=instantiate_project, - status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( - run_results)) - else: - instantiate_testrail.update_testrail(case_id=test_cases["2g_wpa_bridge"], run_id=instantiate_project, - status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( - run_results)) - assert staConnect.passes() - - @pytest.mark.wpa - @pytest.mark.fiveg - @allure.story('wpa 5 GHZ Band') - def test_wpa_ssid_5g(self): - ssid_data = setup_params_general["ssid_modes"]["wpa"][1] - print(ssid_data) - assert "setup_client_connectivity" - - @pytest.mark.wpa2_personal - @pytest.mark.twog - @allure.story('wpa2_personal 2.4 GHZ Band') - def test_wpa2_personal_ssid_2g(self): - ssid_data = setup_params_general["ssid_modes"]["wpa2_personal"][0] - print(ssid_data) - assert "setup_client_connectivity" - - @pytest.mark.wpa2_personal - @pytest.mark.fiveg - @allure.story('wpa2_personal 5 GHZ Band') - def test_wpa2_personal_ssid_5g(self): - ssid_data = setup_params_general["ssid_modes"]["wpa2_personal"][1] - print(ssid_data) - assert "setup_client_connectivity" diff --git a/tests/e2e/basic/client_connectivity_test/bridge/enterprise_security_modes/test_configuration_enterprise_modes.py b/tests/e2e/basic/client_connectivity_test/bridge/enterprise_security_modes/test_configuration_enterprise_modes.py deleted file mode 100644 index 4c9a03b6d..000000000 --- a/tests/e2e/basic/client_connectivity_test/bridge/enterprise_security_modes/test_configuration_enterprise_modes.py +++ /dev/null @@ -1,55 +0,0 @@ -import pytest -import allure - -pytestmark = [pytest.mark.client_connectivity, pytest.mark.enterprise, pytest.mark.bridge, pytest.mark.configuration] - -setup_params_enterprise = { - "mode": "BRIDGE", - "ssid_modes": { - "wpa2_enterprise": [ - {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}], - "wpa3_enterprise": [ - {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, - {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, - - "rf": {}, - "radius": True -} - - -@pytest.mark.parametrize( - 'setup_client_connectivity', - [setup_params_enterprise], - indirect=True, - scope="package" -) -@pytest.mark.usefixtures("setup_client_connectivity") -class TestBridgeModeEnterprise(object): - - @pytest.mark.wpa2_enterprise - @pytest.mark.twog - def test_wpa2_enterprise_2g(self): - # print(setup_client_connectivity) - assert "setup_client_connectivity" - - @pytest.mark.wpa2_enterprise - @pytest.mark.fiveg - def test_wpa2_enterprise_5g(self): - assert "setup_client_connectivity" - - @pytest.mark.wpa3_enterprise - @pytest.mark.twog - def test_wpa3_enterprise_2g(self): - # print(setup_client_connectivity) - assert "setup_client_connectivity" - - @pytest.mark.wpa3_enterprise - @pytest.mark.fiveg - def test_wpa3_enterprise_5g(self): - assert "setup_client_connectivity" - - - - diff --git a/tests/e2e/basic/client_connectivity_test/bridge/enterprise_security_modes/test_enterprise_security.py b/tests/e2e/basic/client_connectivity_test/bridge/enterprise_security_modes/test_enterprise_security.py deleted file mode 100644 index 5c53e5772..000000000 --- a/tests/e2e/basic/client_connectivity_test/bridge/enterprise_security_modes/test_enterprise_security.py +++ /dev/null @@ -1,55 +0,0 @@ -import pytest -import allure - -pytestmark = [pytest.mark.client_connectivity, pytest.mark.enterprise, pytest.mark.bridge] - -setup_params_enterprise = { - "mode": "BRIDGE", - "ssid_modes": { - "wpa2_enterprise": [ - {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}], - "wpa3_enterprise": [ - {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, - {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, - - "rf": {}, - "radius": True -} - - -@pytest.mark.parametrize( - 'setup_client_connectivity', - [setup_params_enterprise], - indirect=True, - scope="package" -) -@pytest.mark.usefixtures("setup_client_connectivity") -class TestBridgeModeEnterprise(object): - - @pytest.mark.wpa2_enterprise - @pytest.mark.twog - def test_wpa2_enterprise_2g(self,): - # print(setup_client_connectivity) - assert "setup_client_connectivity" - - @pytest.mark.wpa2_enterprise - @pytest.mark.fiveg - def test_wpa2_enterprise_5g(self): - assert "setup_client_connectivity" - - @pytest.mark.wpa3_enterprise - @pytest.mark.twog - def test_wpa3_enterprise_2g(self): - # print(setup_client_connectivity) - assert "setup_client_connectivity" - - @pytest.mark.wpa3_enterprise - @pytest.mark.fiveg - def test_wpa3_enterprise_5g(self): - assert "setup_client_connectivity" - - - - diff --git a/tests/e2e/basic/client_connectivity_test/conftest.py b/tests/e2e/basic/client_connectivity_test/conftest.py deleted file mode 100644 index a6e899ead..000000000 --- a/tests/e2e/basic/client_connectivity_test/conftest.py +++ /dev/null @@ -1,344 +0,0 @@ -import time - -import pytest -import allure - - -@pytest.fixture(scope="session") -def setup_vlan(): - vlan_id = [100] - allure.attach(body=str(vlan_id), name="VLAN Created: ") - yield vlan_id[0] - - -@allure.feature("CLIENT CONNECTIVITY SETUP") -@pytest.fixture(scope="package") -def setup_client_connectivity(request, instantiate_controller, testbed, setup_vlan, get_equipment_id, - instantiate_profile, get_markers, - get_security_flags, get_configuration, radius_info, get_apnos): - instantiate_profile = instantiate_profile(sdk_client=instantiate_controller) - vlan_id, mode = 0, 0 - instantiate_profile.cleanup_objects() - parameter = dict(request.param) - test_cases = {} - profile_data = {} - if parameter['mode'] not in ["BRIDGE", "NAT", "VLAN"]: - print("Invalid Mode: ", parameter['mode']) - allure.attach(body=parameter['mode'], name="Invalid Mode: ") - yield test_cases - - if parameter['mode'] == "NAT": - mode = "NAT" - vlan_id = 1 - if parameter['mode'] == "BRIDGE": - mode = "BRIDGE" - vlan_id = 1 - if parameter['mode'] == "VLAN": - mode = "BRIDGE" - vlan_id = setup_vlan - - instantiate_profile.delete_profile_by_name(profile_name=testbed + "-Equipment-AP-" + parameter['mode']) - - profile_data["equipment_ap"] = {"profile_name": testbed + "-Equipment-AP-" + parameter['mode']} - profile_data["ssid"] = {} - for i in parameter["ssid_modes"]: - profile_data["ssid"][i] = [] - for j in range(len(parameter["ssid_modes"][i])): - profile_name = testbed + "-SSID-" + i + "-" + str(j) + "-" + parameter['mode'] - data = parameter["ssid_modes"][i][j] - data["profile_name"] = profile_name - if "mode" not in dict(data).keys(): - data["mode"] = mode - if "vlan" not in dict(data).keys(): - data["vlan"] = vlan_id - instantiate_profile.delete_profile_by_name(profile_name=profile_name) - profile_data["ssid"][i].append(data) - # print(profile_name) - # print(profile_data) - - instantiate_profile.delete_profile_by_name(profile_name=testbed + "-Automation-Radius-Profile-" + mode) - time.sleep(10) - """ - Setting up rf profile - """ - rf_profile_data = { - "name": "RF-Profile-" + testbed + "-" + parameter['mode'] + "-" + - get_configuration[testbed]['access_point'][0]['mode'] - } - - for i in parameter["rf"]: - rf_profile_data[i] = parameter['rf'][i] - # print(rf_profile_data) - - try: - instantiate_profile.delete_profile_by_name(profile_name=rf_profile_data['name']) - instantiate_profile.set_rf_profile(profile_data=rf_profile_data, - mode=get_configuration[testbed]['access_point'][0]['mode']) - allure.attach(body=str(rf_profile_data), - name="RF Profile Created : " + get_configuration[testbed]['access_point'][0]['mode']) - except Exception as e: - print(e) - allure.attach(body=str(e), name="Exception ") - - # Radius Profile Creation - if parameter["radius"]: - radius_info = radius_info - radius_info["name"] = testbed + "-Automation-Radius-Profile-" + testbed - instantiate_profile.delete_profile_by_name(profile_name=testbed + "-Automation-Radius-Profile-" + testbed) - try: - # pass - instantiate_profile.create_radius_profile(radius_info=radius_info) - allure.attach(body=str(radius_info), - name="Radius Profile Created") - test_cases['radius_profile'] = True - except Exception as e: - print(e) - test_cases['radius_profile'] = False - - # SSID Profile Creation - print(get_markers) - for mode in profile_data['ssid']: - if mode == "open": - for j in profile_data["ssid"][mode]: - # print(j) - if mode in get_markers.keys() and get_markers[mode]: - try: - if "twog" in get_markers.keys() and get_markers["twog"] and "is2dot4GHz" in list( - j["appliedRadios"]): - creates_profile = instantiate_profile.create_open_ssid_profile(profile_data=j) - test_cases["open_2g"] = True - allure.attach(body=str(creates_profile), - name="SSID Profile Created") - except Exception as e: - print(e) - test_cases["open_2g"] = False - allure.attach(body=str(e), - name="SSID Profile Creation Failed") - - try: - if "fiveg" in get_markers.keys() and get_markers["fiveg"] and "is5GHz" in list( - j["appliedRadios"]): - creates_profile = instantiate_profile.create_open_ssid_profile(profile_data=j) - test_cases["open_5g"] = True - allure.attach(body=str(creates_profile), - name="SSID Profile Created") - except Exception as e: - print(e) - test_cases["open_5g"] = False - allure.attach(body=str(e), - name="SSID Profile Creation Failed") - - if mode == "wpa": - for j in profile_data["ssid"][mode]: - # print(j) - if mode in get_markers.keys() and get_markers[mode]: - try: - if "twog" in get_markers.keys() and get_markers["twog"] and "is2dot4GHz" in list( - j["appliedRadios"]): - creates_profile = instantiate_profile.create_wpa_ssid_profile(profile_data=j) - test_cases["wpa_2g"] = True - allure.attach(body=str(creates_profile), - name="SSID Profile Created") - except Exception as e: - print(e) - test_cases["wpa_2g"] = False - allure.attach(body=str(e), - name="SSID Profile Creation Failed") - try: - if "fiveg" in get_markers.keys() and get_markers["fiveg"] and "is5GHz" in list( - j["appliedRadios"]): - creates_profile = instantiate_profile.create_wpa_ssid_profile(profile_data=j) - test_cases["wpa_5g"] = True - allure.attach(body=str(creates_profile), - name="SSID Profile Created") - except Exception as e: - print(e) - test_cases["wpa_5g"] = False - allure.attach(body=str(e), - name="SSID Profile Creation Failed") - if mode == "wpa2_personal": - for j in profile_data["ssid"][mode]: - # print(j) - if mode in get_markers.keys() and get_markers[mode]: - try: - if "twog" in get_markers.keys() and get_markers["twog"] and "is2dot4GHz" in list( - j["appliedRadios"]): - creates_profile = instantiate_profile.create_wpa2_personal_ssid_profile(profile_data=j) - test_cases["wpa2_personal_2g"] = True - allure.attach(body=str(creates_profile), - name="SSID Profile Created") - except Exception as e: - print(e) - test_cases["wpa2_personal_2g"] = False - allure.attach(body=str(e), - name="SSID Profile Creation Failed") - try: - if "fiveg" in get_markers.keys() and get_markers["fiveg"] and "is5GHz" in list( - j["appliedRadios"]): - creates_profile = instantiate_profile.create_wpa2_personal_ssid_profile(profile_data=j) - test_cases["wpa2_personal_5g"] = True - allure.attach(body=str(creates_profile), - name="SSID Profile Created") - except Exception as e: - print(e) - test_cases["wpa2_personal_5g"] = False - allure.attach(body=str(e), - name="SSID Profile Creation Failed") - - if mode == "wpa3_personal": - for j in profile_data["ssid"][mode]: - # print(j) - if mode in get_markers.keys() and get_markers[mode]: - try: - if "twog" in get_markers.keys() and get_markers["twog"] and "is2dot4GHz" in list( - j["appliedRadios"]): - creates_profile = instantiate_profile.create_wpa3_personal_ssid_profile(profile_data=j) - test_cases["wpa3_personal_2g"] = True - allure.attach(body=str(creates_profile), - name="SSID Profile Created") - except Exception as e: - print(e) - test_cases["wpa3_personal_2g"] = False - allure.attach(body=str(e), - name="SSID Profile Creation Failed") - try: - if "fiveg" in get_markers.keys() and get_markers["fiveg"] and "is5GHz" in list( - j["appliedRadios"]): - creates_profile = instantiate_profile.create_wpa3_personal_ssid_profile(profile_data=j) - test_cases["wpa3_personal_5g"] = True - allure.attach(body=str(creates_profile), - name="SSID Profile Created") - except Exception as e: - print(e) - test_cases["wpa3_personal_5g"] = False - allure.attach(body=str(e), - name="SSID Profile Creation Failed") - - if mode == "wpa2_enterprise": - for j in profile_data["ssid"][mode]: - # print(j) - if mode in get_markers.keys() and get_markers[mode]: - try: - if "twog" in get_markers.keys() and get_markers["twog"] and "is2dot4GHz" in list( - j["appliedRadios"]): - creates_profile = instantiate_profile.create_wpa2_enterprise_ssid_profile(profile_data=j) - test_cases["wpa2_enterprise_2g"] = True - allure.attach(body=str(creates_profile), - name="SSID Profile Created") - except Exception as e: - print(e) - test_cases["wpa2_enterprise_2g"] = False - allure.attach(body=str(e), - name="SSID Profile Creation Failed") - try: - if "fiveg" in get_markers.keys() and get_markers["fiveg"] and "is5GHz" in list( - j["appliedRadios"]): - creates_profile = instantiate_profile.create_wpa2_enterprise_ssid_profile(profile_data=j) - test_cases["wpa2_enterprise_5g"] = True - allure.attach(body=str(creates_profile), - name="SSID Profile Created") - except Exception as e: - print(e) - test_cases["wpa2_enterprise_5g"] = False - allure.attach(body=str(e), - name="SSID Profile Creation Failed") - - if mode == "wpa3_enterprise": - for j in profile_data["ssid"][mode]: - # print(j) - if mode in get_markers.keys() and get_markers[mode]: - try: - if "twog" in get_markers.keys() and get_markers["twog"] and "is2dot4GHz" in list( - j["appliedRadios"]): - creates_profile = instantiate_profile.create_wpa3_enterprise_ssid_profile(profile_data=j) - test_cases["wpa3_enterprise_2g"] = True - allure.attach(body=str(creates_profile), - name="SSID Profile Created") - except Exception as e: - print(e) - test_cases["wpa3_enterprise_2g"] = False - allure.attach(body=str(e), - name="SSID Profile Creation Failed") - try: - if "fiveg" in get_markers.keys() and get_markers["fiveg"] and "is5GHz" in list( - j["appliedRadios"]): - creates_profile = instantiate_profile.create_wpa3_enterprise_ssid_profile(profile_data=j) - test_cases["wpa3_enterprise_5g"] = True - allure.attach(body=str(creates_profile), - name="SSID Profile Created") - except Exception as e: - print(e) - test_cases["wpa3_enterprise_5g"] = False - allure.attach(body=str(e), - name="SSID Profile Creation Failed") - - # Equipment AP Profile Creation - try: - instantiate_profile.set_ap_profile(profile_data=profile_data['equipment_ap']) - test_cases["equipment_ap"] = True - allure.attach(body=str(profile_data['equipment_ap']), - name="Equipment AP Profile Created") - except Exception as e: - print(e) - test_cases["equipment_ap"] = False - allure.attach(body=str(e), - name="Equipment AP Profile Creation Failed") - - # Push the Equipment AP Profile to AP - try: - instantiate_profile.push_profile_old_method(equipment_id=get_equipment_id) - except Exception as e: - print(e) - print("failed to create AP Profile") - - ap_ssh = get_apnos(get_configuration[testbed]['access_point'][0], pwd="../libs/apnos/") - ssid_names = [] - for i in instantiate_profile.profile_creation_ids["ssid"]: - ssid_names.append(instantiate_profile.get_ssid_name_by_profile_id(profile_id=i)) - ssid_names.sort() - - # This loop will check the VIF Config with cloud profile - vif_config = [] - test_cases['vifc'] = False - for i in range(0, 18): - vif_config = list(ap_ssh.get_vif_config_ssids()) - vif_config.sort() - print(vif_config) - print(ssid_names) - if ssid_names == vif_config: - test_cases['vifc'] = True - break - time.sleep(10) - allure.attach(body=str("VIF Config: " + str(vif_config) + "\n" + "SSID Pushed from Controller: " + str(ssid_names)), - name="SSID Profiles in VIF Config and Controller: ") - ap_ssh = get_apnos(get_configuration[testbed]['access_point'][0], pwd="../libs/apnos/") - - # This loop will check the VIF Config with VIF State - test_cases['vifs'] = False - for i in range(0, 18): - vif_state = list(ap_ssh.get_vif_state_ssids()) - vif_state.sort() - vif_config = list(ap_ssh.get_vif_config_ssids()) - vif_config.sort() - print(vif_config) - print(vif_state) - if vif_state == vif_config: - test_cases['vifs'] = True - break - time.sleep(10) - allure.attach(body=str("VIF Config: " + str(vif_config) + "\n" + "VIF State: " + str(vif_state)), - name="SSID Profiles in VIF Config and VIF State: ") - print(test_cases) - - def teardown_session(): - print("\nRemoving Profiles") - instantiate_profile.delete_profile_by_name(profile_name=profile_data['equipment_ap']['profile_name']) - instantiate_profile.delete_profile(instantiate_profile.profile_creation_ids["ssid"]) - instantiate_profile.delete_profile(instantiate_profile.profile_creation_ids["radius"]) - instantiate_profile.delete_profile(instantiate_profile.profile_creation_ids["rf"]) - allure.attach(body=str(profile_data['equipment_ap']['profile_name'] + "\n"), - name="Tear Down in Profiles ") - time.sleep(20) - - request.addfinalizer(teardown_session) - yield test_cases diff --git a/tests/e2e/basic/client_connectivity_test/nat/basic_security_modes/test_basic_security.py b/tests/e2e/basic/client_connectivity_test/nat/basic_security_modes/test_basic_security.py deleted file mode 100644 index 5cb063d75..000000000 --- a/tests/e2e/basic/client_connectivity_test/nat/basic_security_modes/test_basic_security.py +++ /dev/null @@ -1,78 +0,0 @@ -import pytest -import allure - -pytestmark = [pytest.mark.client_connectivity, pytest.mark.nat] - -setup_params_general = { - "mode": "NAT", - "ssid_modes": { - "open": [{"ssid_name": "ssid_open_2g", "appliedRadios": ["is2dot4GHz"]}, - {"ssid_name": "ssid_open_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], - "wpa": [{"ssid_name": "ssid_wpa_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}], - "wpa2_personal": [ - {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}]}, - "rf": {}, - "radius": False -} - - -@allure.feature("NAT MODE CLIENT CONNECTIVITY") -@pytest.mark.parametrize( - 'setup_client_connectivity', - [setup_params_general], - indirect=True, - scope="package" -) -@pytest.mark.usefixtures("setup_client_connectivity") -class TestNATModeConnectivity(object): - - - @pytest.mark.open - @pytest.mark.twog - @allure.story('open 2.4 GHZ Band') - def test_open_ssid_2g(self): - ssid_data = setup_params_general["ssid_modes"]["open"][0] - - assert "setup_client_connectivity" - - @pytest.mark.open - @pytest.mark.fiveg - @allure.story('open 5 GHZ Band') - def test_open_ssid_5g(self): - ssid_data = setup_params_general["ssid_modes"]["open"][1] - assert "setup_client_connectivity" - - @pytest.mark.wpa - @pytest.mark.twog - @allure.story('wpa 2.4 GHZ Band') - def test_wpa_ssid_2g(self): - ssid_data = setup_params_general["ssid_modes"]["wpa"][0] - # print(setup_client_connectivity) - assert "setup_client_connectivity" - - @pytest.mark.wpa - @pytest.mark.fiveg - @allure.story('wpa 5 GHZ Band') - def test_wpa_ssid_5g(self): - ssid_data = setup_params_general["ssid_modes"]["wpa"][1] - assert "setup_client_connectivity" - - @pytest.mark.wpa2_personal - @pytest.mark.twog - @allure.story('wpa2_personal 2.4 GHZ Band') - def test_wpa2_personal_ssid_2g(self): - ssid_data = setup_params_general["ssid_modes"]["wpa2_personal"][0] - # print(setup_client_connectivity) - assert "setup_client_connectivity" - - @pytest.mark.wpa2_personal - @pytest.mark.fiveg - @allure.story('wpa2_personal 5 GHZ Band') - def test_wpa2_personal_ssid_5g(self): - ssid_data = setup_params_general["ssid_modes"]["wpa2_personal"][1] - assert "setup_client_connectivity" - diff --git a/tests/e2e/basic/client_connectivity_test/nat/basic_security_modes/test_configuration_basic_modes.py b/tests/e2e/basic/client_connectivity_test/nat/basic_security_modes/test_configuration_basic_modes.py deleted file mode 100644 index 4d1afd556..000000000 --- a/tests/e2e/basic/client_connectivity_test/nat/basic_security_modes/test_configuration_basic_modes.py +++ /dev/null @@ -1,78 +0,0 @@ -import pytest -import allure - -pytestmark = [pytest.mark.client_connectivity, pytest.mark.nat, pytest.mark.configuration] - -setup_params_general = { - "mode": "NAT", - "ssid_modes": { - "open": [{"ssid_name": "ssid_open_2g", "appliedRadios": ["is2dot4GHz"]}, - {"ssid_name": "ssid_open_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], - "wpa": [{"ssid_name": "ssid_wpa_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}], - "wpa2_personal": [ - {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}]}, - "rf": {}, - "radius": False -} - - -@allure.feature("NAT MODE CLIENT CONNECTIVITY") -@pytest.mark.parametrize( - 'setup_client_connectivity', - [setup_params_general], - indirect=True, - scope="package" -) -@pytest.mark.usefixtures("setup_client_connectivity") -class TestNATModeConnectivity(object): - - - @pytest.mark.open - @pytest.mark.twog - @allure.story('open 2.4 GHZ Band') - def test_open_ssid_2g(self, setup_client_connectivity): - ssid_data = setup_params_general["ssid_modes"]["open"][0] - allure.attach(str(setup_client_connectivity), 'Hello, World') - assert setup_client_connectivity - - @pytest.mark.open - @pytest.mark.fiveg - @allure.story('open 5 GHZ Band') - def test_open_ssid_5g(self, setup_client_connectivity): - ssid_data = setup_params_general["ssid_modes"]["open"][1] - assert setup_client_connectivity - - @pytest.mark.wpa - @pytest.mark.twog - @allure.story('wpa 2.4 GHZ Band') - def test_wpa_ssid_2g(self, setup_client_connectivity): - ssid_data = setup_params_general["ssid_modes"]["wpa"][0] - print(setup_client_connectivity) - assert setup_client_connectivity - - @pytest.mark.wpa - @pytest.mark.fiveg - @allure.story('wpa 5 GHZ Band') - def test_wpa_ssid_5g(self, setup_client_connectivity): - ssid_data = setup_params_general["ssid_modes"]["wpa"][1] - assert setup_client_connectivity - - @pytest.mark.wpa2_personal - @pytest.mark.twog - @allure.story('wpa2_personal 2.4 GHZ Band') - def test_wpa2_personal_ssid_2g(self, setup_client_connectivity): - ssid_data = setup_params_general["ssid_modes"]["wpa2_personal"][0] - print(setup_client_connectivity) - assert setup_client_connectivity - - @pytest.mark.wpa2_personal - @pytest.mark.fiveg - @allure.story('wpa2_personal 5 GHZ Band') - def test_wpa2_personal_ssid_5g(self, setup_client_connectivity): - ssid_data = setup_params_general["ssid_modes"]["wpa2_personal"][1] - assert setup_client_connectivity - diff --git a/tests/e2e/basic/client_connectivity_test/nat/enterprise_security_modes/test_configuration_enterprise_modes.py b/tests/e2e/basic/client_connectivity_test/nat/enterprise_security_modes/test_configuration_enterprise_modes.py deleted file mode 100644 index 4f7ed2f61..000000000 --- a/tests/e2e/basic/client_connectivity_test/nat/enterprise_security_modes/test_configuration_enterprise_modes.py +++ /dev/null @@ -1,55 +0,0 @@ -import pytest -import allure - -pytestmark = [pytest.mark.client_connectivity, pytest.mark.enterprise, pytest.mark.nat, pytest.mark.configuration] - -setup_params_enterprise = { - "mode": "NAT", - "ssid_modes": { - "wpa2_enterprise": [ - {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}], - "wpa3_enterprise": [ - {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, - {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, - - "rf": {}, - "radius": True -} - - -@pytest.mark.parametrize( - 'setup_client_connectivity', - [setup_params_enterprise], - indirect=True, - scope="package" -) -@pytest.mark.usefixtures("setup_client_connectivity") -class TestNATModeEnterprise(object): - - @pytest.mark.wpa2_enterprise - @pytest.mark.twog - def test_wpa2_enterprise_2g(self): - # print(setup_client_connectivity) - assert "setup_client_connectivity" - - @pytest.mark.wpa2_enterprise - @pytest.mark.fiveg - def test_wpa2_enterprise_5g(self): - assert "setup_client_connectivity" - - @pytest.mark.wpa3_enterprise - @pytest.mark.twog - def test_wpa3_enterprise_2g(self): - # print(setup_client_connectivity) - assert "setup_client_connectivity" - - @pytest.mark.wpa3_enterprise - @pytest.mark.fiveg - def test_wpa3_enterprise_5g(self): - assert "setup_client_connectivity" - - - - diff --git a/tests/e2e/basic/client_connectivity_test/nat/enterprise_security_modes/test_enterprise_security.py b/tests/e2e/basic/client_connectivity_test/nat/enterprise_security_modes/test_enterprise_security.py deleted file mode 100644 index 6cd94238d..000000000 --- a/tests/e2e/basic/client_connectivity_test/nat/enterprise_security_modes/test_enterprise_security.py +++ /dev/null @@ -1,55 +0,0 @@ -import pytest -import allure - -pytestmark = [pytest.mark.client_connectivity, pytest.mark.enterprise, pytest.mark.nat] - -setup_params_enterprise = { - "mode": "NAT", - "ssid_modes": { - "wpa2_enterprise": [ - {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}], - "wpa3_enterprise": [ - {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, - {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, - - "rf": {}, - "radius": True -} - - -@pytest.mark.parametrize( - 'setup_client_connectivity', - [setup_params_enterprise], - indirect=True, - scope="package" -) -@pytest.mark.usefixtures("setup_client_connectivity") -class TestNATModeEnterprise(object): - - @pytest.mark.wpa2_enterprise - @pytest.mark.twog - def test_wpa2_enterprise_2g(self,): - # print(setup_client_connectivity) - assert "setup_client_connectivity" - - @pytest.mark.wpa2_enterprise - @pytest.mark.fiveg - def test_wpa2_enterprise_5g(self): - assert "setup_client_connectivity" - - @pytest.mark.wpa3_enterprise - @pytest.mark.twog - def test_wpa3_enterprise_2g(self): - # print(setup_client_connectivity) - assert "setup_client_connectivity" - - @pytest.mark.wpa3_enterprise - @pytest.mark.fiveg - def test_wpa3_enterprise_5g(self): - assert "setup_client_connectivity" - - - - diff --git a/tests/e2e/basic/client_connectivity_test/vlan/basic_security_modes/test_basic_security.py b/tests/e2e/basic/client_connectivity_test/vlan/basic_security_modes/test_basic_security.py deleted file mode 100644 index 410dc7071..000000000 --- a/tests/e2e/basic/client_connectivity_test/vlan/basic_security_modes/test_basic_security.py +++ /dev/null @@ -1,78 +0,0 @@ -import pytest -import allure - -pytestmark = [pytest.mark.client_connectivity, pytest.mark.vlan] - -setup_params_general = { - "mode": "VLAN", - "ssid_modes": { - "open": [{"ssid_name": "ssid_open_2g", "appliedRadios": ["is2dot4GHz"]}, - {"ssid_name": "ssid_open_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], - "wpa": [{"ssid_name": "ssid_wpa_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}], - "wpa2_personal": [ - {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}]}, - "rf": {}, - "radius": False -} - - -@allure.feature("VLAN MODE CLIENT CONNECTIVITY") -@pytest.mark.parametrize( - 'setup_client_connectivity', - [setup_params_general], - indirect=True, - scope="package" -) -@pytest.mark.usefixtures("setup_client_connectivity") -class TestVLANModeConnectivity(object): - - - @pytest.mark.open - @pytest.mark.twog - @allure.story('open 2.4 GHZ Band') - def test_open_ssid_2g(self): - ssid_data = setup_params_general["ssid_modes"]["open"][0] - - assert "setup_client_connectivity" - - @pytest.mark.open - @pytest.mark.fiveg - @allure.story('open 5 GHZ Band') - def test_open_ssid_5g(self): - ssid_data = setup_params_general["ssid_modes"]["open"][1] - assert "setup_client_connectivity" - - @pytest.mark.wpa - @pytest.mark.twog - @allure.story('wpa 2.4 GHZ Band') - def test_wpa_ssid_2g(self): - ssid_data = setup_params_general["ssid_modes"]["wpa"][0] - # print(setup_client_connectivity) - assert "setup_client_connectivity" - - @pytest.mark.wpa - @pytest.mark.fiveg - @allure.story('wpa 5 GHZ Band') - def test_wpa_ssid_5g(self): - ssid_data = setup_params_general["ssid_modes"]["wpa"][1] - assert "setup_client_connectivity" - - @pytest.mark.wpa2_personal - @pytest.mark.twog - @allure.story('wpa2_personal 2.4 GHZ Band') - def test_wpa2_personal_ssid_2g(self): - ssid_data = setup_params_general["ssid_modes"]["wpa2_personal"][0] - # print(setup_client_connectivity) - assert "setup_client_connectivity" - - @pytest.mark.wpa2_personal - @pytest.mark.fiveg - @allure.story('wpa2_personal 5 GHZ Band') - def test_wpa2_personal_ssid_5g(self): - ssid_data = setup_params_general["ssid_modes"]["wpa2_personal"][1] - assert "setup_client_connectivity" - diff --git a/tests/e2e/basic/client_connectivity_test/vlan/basic_security_modes/test_configuration_basic_modes.py b/tests/e2e/basic/client_connectivity_test/vlan/basic_security_modes/test_configuration_basic_modes.py deleted file mode 100644 index b5c07a1e6..000000000 --- a/tests/e2e/basic/client_connectivity_test/vlan/basic_security_modes/test_configuration_basic_modes.py +++ /dev/null @@ -1,78 +0,0 @@ -import pytest -import allure - -pytestmark = [pytest.mark.client_connectivity, pytest.mark.vlan, pytest.mark.configuration] - -setup_params_general = { - "mode": "VLAN", - "ssid_modes": { - "open": [{"ssid_name": "ssid_open_2g", "appliedRadios": ["is2dot4GHz"]}, - {"ssid_name": "ssid_open_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], - "wpa": [{"ssid_name": "ssid_wpa_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}], - "wpa2_personal": [ - {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}]}, - "rf": {}, - "radius": False -} - - -@allure.feature("VLAN MODE CLIENT CONNECTIVITY") -@pytest.mark.parametrize( - 'setup_client_connectivity', - [setup_params_general], - indirect=True, - scope="package" -) -@pytest.mark.usefixtures("setup_client_connectivity") -class TestVLANModeConnectivity(object): - - - @pytest.mark.open - @pytest.mark.twog - @allure.story('open 2.4 GHZ Band') - def test_open_ssid_2g(self, setup_client_connectivity): - ssid_data = setup_params_general["ssid_modes"]["open"][0] - allure.attach(str(setup_client_connectivity), 'Hello, World') - assert setup_client_connectivity - - @pytest.mark.open - @pytest.mark.fiveg - @allure.story('open 5 GHZ Band') - def test_open_ssid_5g(self, setup_client_connectivity): - ssid_data = setup_params_general["ssid_modes"]["open"][1] - assert setup_client_connectivity - - @pytest.mark.wpa - @pytest.mark.twog - @allure.story('wpa 2.4 GHZ Band') - def test_wpa_ssid_2g(self, setup_client_connectivity): - ssid_data = setup_params_general["ssid_modes"]["wpa"][0] - print(setup_client_connectivity) - assert setup_client_connectivity - - @pytest.mark.wpa - @pytest.mark.fiveg - @allure.story('wpa 5 GHZ Band') - def test_wpa_ssid_5g(self, setup_client_connectivity): - ssid_data = setup_params_general["ssid_modes"]["wpa"][1] - assert setup_client_connectivity - - @pytest.mark.wpa2_personal - @pytest.mark.twog - @allure.story('wpa2_personal 2.4 GHZ Band') - def test_wpa2_personal_ssid_2g(self, setup_client_connectivity): - ssid_data = setup_params_general["ssid_modes"]["wpa2_personal"][0] - print(setup_client_connectivity) - assert setup_client_connectivity - - @pytest.mark.wpa2_personal - @pytest.mark.fiveg - @allure.story('wpa2_personal 5 GHZ Band') - def test_wpa2_personal_ssid_5g(self, setup_client_connectivity): - ssid_data = setup_params_general["ssid_modes"]["wpa2_personal"][1] - assert setup_client_connectivity - diff --git a/tests/e2e/basic/client_connectivity_test/vlan/enterprise_security_modes/test_configuration_enterprise_modes.py b/tests/e2e/basic/client_connectivity_test/vlan/enterprise_security_modes/test_configuration_enterprise_modes.py deleted file mode 100644 index 4c9a03b6d..000000000 --- a/tests/e2e/basic/client_connectivity_test/vlan/enterprise_security_modes/test_configuration_enterprise_modes.py +++ /dev/null @@ -1,55 +0,0 @@ -import pytest -import allure - -pytestmark = [pytest.mark.client_connectivity, pytest.mark.enterprise, pytest.mark.bridge, pytest.mark.configuration] - -setup_params_enterprise = { - "mode": "BRIDGE", - "ssid_modes": { - "wpa2_enterprise": [ - {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}], - "wpa3_enterprise": [ - {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, - {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, - - "rf": {}, - "radius": True -} - - -@pytest.mark.parametrize( - 'setup_client_connectivity', - [setup_params_enterprise], - indirect=True, - scope="package" -) -@pytest.mark.usefixtures("setup_client_connectivity") -class TestBridgeModeEnterprise(object): - - @pytest.mark.wpa2_enterprise - @pytest.mark.twog - def test_wpa2_enterprise_2g(self): - # print(setup_client_connectivity) - assert "setup_client_connectivity" - - @pytest.mark.wpa2_enterprise - @pytest.mark.fiveg - def test_wpa2_enterprise_5g(self): - assert "setup_client_connectivity" - - @pytest.mark.wpa3_enterprise - @pytest.mark.twog - def test_wpa3_enterprise_2g(self): - # print(setup_client_connectivity) - assert "setup_client_connectivity" - - @pytest.mark.wpa3_enterprise - @pytest.mark.fiveg - def test_wpa3_enterprise_5g(self): - assert "setup_client_connectivity" - - - - diff --git a/tests/e2e/basic/client_connectivity_test/vlan/enterprise_security_modes/test_enterprise_security.py b/tests/e2e/basic/client_connectivity_test/vlan/enterprise_security_modes/test_enterprise_security.py deleted file mode 100644 index 5c53e5772..000000000 --- a/tests/e2e/basic/client_connectivity_test/vlan/enterprise_security_modes/test_enterprise_security.py +++ /dev/null @@ -1,55 +0,0 @@ -import pytest -import allure - -pytestmark = [pytest.mark.client_connectivity, pytest.mark.enterprise, pytest.mark.bridge] - -setup_params_enterprise = { - "mode": "BRIDGE", - "ssid_modes": { - "wpa2_enterprise": [ - {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}], - "wpa3_enterprise": [ - {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, - {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, - - "rf": {}, - "radius": True -} - - -@pytest.mark.parametrize( - 'setup_client_connectivity', - [setup_params_enterprise], - indirect=True, - scope="package" -) -@pytest.mark.usefixtures("setup_client_connectivity") -class TestBridgeModeEnterprise(object): - - @pytest.mark.wpa2_enterprise - @pytest.mark.twog - def test_wpa2_enterprise_2g(self,): - # print(setup_client_connectivity) - assert "setup_client_connectivity" - - @pytest.mark.wpa2_enterprise - @pytest.mark.fiveg - def test_wpa2_enterprise_5g(self): - assert "setup_client_connectivity" - - @pytest.mark.wpa3_enterprise - @pytest.mark.twog - def test_wpa3_enterprise_2g(self): - # print(setup_client_connectivity) - assert "setup_client_connectivity" - - @pytest.mark.wpa3_enterprise - @pytest.mark.fiveg - def test_wpa3_enterprise_5g(self): - assert "setup_client_connectivity" - - - - diff --git a/tests/e2e/basic/client_connectivity_test/__init__.py b/tests/e2e/basic/configuration_tests/__init__.py similarity index 100% rename from tests/e2e/basic/client_connectivity_test/__init__.py rename to tests/e2e/basic/configuration_tests/__init__.py diff --git a/tests/e2e/basic/conftest.py b/tests/e2e/basic/conftest.py index 902b33d25..69dc3f025 100644 --- a/tests/e2e/basic/conftest.py +++ b/tests/e2e/basic/conftest.py @@ -1,39 +1,49 @@ -import time +import os +import sys +sys.path.append( + os.path.dirname( + os.path.realpath(__file__) + ) +) +if "libs" not in sys.path: + sys.path.append(f'../libs') + +from controller.controller import ProfileUtility +import time +from lanforge.lf_tests import RunTest import pytest import allure +@pytest.fixture(scope="session") +def get_equipment_id(setup_controller, testbed, get_configuration): + equipment_id = 0 + if len(get_configuration['access_point']) == 1: + equipment_id = setup_controller.get_equipment_id( + serial_number=get_configuration['access_point'][0]['serial']) + print(equipment_id) + yield equipment_id + + +@pytest.fixture(scope="session") +def instantiate_profile(): + yield ProfileUtility + + @pytest.fixture(scope="session") def setup_vlan(): vlan_id = [100] allure.attach(body=str(vlan_id), name="VLAN Created: ") yield vlan_id[0] -@pytest.fixture(scope="session") -def get_equipment_id(instantiate_controller, testbed): - equipment_id = 0 - if len(CONFIGURATION[testbed]['access_point']) == 1: - equipment_id = instantiate_controller.get_equipment_id( - serial_number=CONFIGURATION[testbed]['access_point'][0]['serial']) - print(equipment_id) - yield equipment_id - -@pytest.fixture(scope="module") -def instantiate_profile(instantiate_controller): - try: - profile_object = ProfileUtility(sdk_client=instantiate_controller) - except Exception as e: - profile_object = False - yield profile_object - @allure.feature("CLIENT CONNECTIVITY SETUP") -@pytest.fixture(scope="package") -def setup_client_connectivity(request, instantiate_controller, testbed, setup_vlan, get_equipment_id, +@pytest.fixture(scope="class") +def setup_profiles(request, setup_controller, testbed, setup_vlan, get_equipment_id, instantiate_profile, get_markers, get_security_flags, get_configuration, radius_info, get_apnos): - instantiate_profile = instantiate_profile(sdk_client=instantiate_controller) + instantiate_profile = instantiate_profile(sdk_client=setup_controller) vlan_id, mode = 0, 0 instantiate_profile.cleanup_objects() parameter = dict(request.param) @@ -80,7 +90,7 @@ def setup_client_connectivity(request, instantiate_controller, testbed, setup_vl """ rf_profile_data = { "name": "RF-Profile-" + testbed + "-" + parameter['mode'] + "-" + - get_configuration[testbed]['access_point'][0]['mode'] + get_configuration['access_point'][0]['mode'] } for i in parameter["rf"]: @@ -90,9 +100,9 @@ def setup_client_connectivity(request, instantiate_controller, testbed, setup_vl try: instantiate_profile.delete_profile_by_name(profile_name=rf_profile_data['name']) instantiate_profile.set_rf_profile(profile_data=rf_profile_data, - mode=get_configuration[testbed]['access_point'][0]['mode']) + mode=get_configuration['access_point'][0]['mode']) allure.attach(body=str(rf_profile_data), - name="RF Profile Created : " + get_configuration[testbed]['access_point'][0]['mode']) + name="RF Profile Created : " + get_configuration['access_point'][0]['mode']) except Exception as e: print(e) allure.attach(body=str(e), name="Exception ") @@ -308,7 +318,7 @@ def setup_client_connectivity(request, instantiate_controller, testbed, setup_vl print(e) print("failed to create AP Profile") - ap_ssh = get_apnos(get_configuration[testbed]['access_point'][0], pwd="../libs/apnos/") + ap_ssh = get_apnos(get_configuration['access_point'][0], pwd="../libs/apnos/") ssid_names = [] for i in instantiate_profile.profile_creation_ids["ssid"]: ssid_names.append(instantiate_profile.get_ssid_name_by_profile_id(profile_id=i)) @@ -328,7 +338,7 @@ def setup_client_connectivity(request, instantiate_controller, testbed, setup_vl time.sleep(10) allure.attach(body=str("VIF Config: " + str(vif_config) + "\n" + "SSID Pushed from Controller: " + str(ssid_names)), name="SSID Profiles in VIF Config and Controller: ") - ap_ssh = get_apnos(get_configuration[testbed]['access_point'][0], pwd="../libs/apnos/") + ap_ssh = get_apnos(get_configuration['access_point'][0], pwd="../libs/apnos/") # This loop will check the VIF Config with VIF State test_cases['vifs'] = False @@ -359,3 +369,9 @@ def setup_client_connectivity(request, instantiate_controller, testbed, setup_vl request.addfinalizer(teardown_session) yield test_cases + + +@pytest.fixture(scope="session") +def lf_test(get_configuration): + obj = RunTest(lanforge_data=get_configuration['traffic_generator']['details']) + yield obj diff --git a/tests/e2e/basic/client_connectivity_test/bridge/__init__.py b/tests/e2e/basic/performance_tests/__init__.py similarity index 100% rename from tests/e2e/basic/client_connectivity_test/bridge/__init__.py rename to tests/e2e/basic/performance_tests/__init__.py diff --git a/tests/e2e/basic/client_connectivity_test/bridge/basic_security_modes/__init__.py b/tests/e2e/basic/performance_tests/dataplane_throughput_test/__init__.py similarity index 100% rename from tests/e2e/basic/client_connectivity_test/bridge/basic_security_modes/__init__.py rename to tests/e2e/basic/performance_tests/dataplane_throughput_test/__init__.py diff --git a/tests/e2e/basic/client_connectivity_test/bridge/enterprise_security_modes/__init__.py b/tests/e2e/basic/performance_tests/dual_band_performance_test/__init__.py similarity index 100% rename from tests/e2e/basic/client_connectivity_test/bridge/enterprise_security_modes/__init__.py rename to tests/e2e/basic/performance_tests/dual_band_performance_test/__init__.py diff --git a/tests/e2e/basic/client_connectivity_test/nat/__init__.py b/tests/e2e/basic/performance_tests/wifi_capacity_test/__init__.py similarity index 100% rename from tests/e2e/basic/client_connectivity_test/nat/__init__.py rename to tests/e2e/basic/performance_tests/wifi_capacity_test/__init__.py diff --git a/tests/e2e/basic/wifi_capacity_test/test_bridge_mode.py b/tests/e2e/basic/performance_tests/wifi_capacity_test/test_bridge_mode.py similarity index 100% rename from tests/e2e/basic/wifi_capacity_test/test_bridge_mode.py rename to tests/e2e/basic/performance_tests/wifi_capacity_test/test_bridge_mode.py diff --git a/tests/e2e/basic/wifi_capacity_test/test_nat_mode.py b/tests/e2e/basic/performance_tests/wifi_capacity_test/test_nat_mode.py similarity index 100% rename from tests/e2e/basic/wifi_capacity_test/test_nat_mode.py rename to tests/e2e/basic/performance_tests/wifi_capacity_test/test_nat_mode.py diff --git a/tests/e2e/basic/wifi_capacity_test/test_vlan_mode.py b/tests/e2e/basic/performance_tests/wifi_capacity_test/test_vlan_mode.py similarity index 100% rename from tests/e2e/basic/wifi_capacity_test/test_vlan_mode.py rename to tests/e2e/basic/performance_tests/wifi_capacity_test/test_vlan_mode.py diff --git a/tests/e2e/basic/test_firmware.py b/tests/e2e/basic/test_firmware.py new file mode 100644 index 000000000..8af8183d6 --- /dev/null +++ b/tests/e2e/basic/test_firmware.py @@ -0,0 +1,81 @@ +""" + Test Case Module: setup test cases for basic test cases + Details: Firmware Upgrade + +""" +import pytest + +@pytest.mark.configure_lanforge +def test_configure_lanforge(configure_lanforge): + + assert True + + +@pytest.mark.sanity +@pytest.mark.bridge +@pytest.mark.nat +@pytest.mark.vlan +@pytest.mark.firmware +class TestFirmware(object): + + @pytest.mark.firmware_create + def test_firmware_create(self, upload_firmware, instantiate_testrail, instantiate_project, test_cases): + if upload_firmware != 0: + instantiate_testrail.update_testrail(case_id=test_cases["create_fw"], run_id=instantiate_project, + status_id=1, + msg='Create new FW version by API successful') + PASS = True + else: + instantiate_testrail.update_testrail(case_id=test_cases["create_fw"], run_id=instantiate_project, + status_id=5, + msg='Error creating new FW version by API') + PASS = False + assert PASS + + @pytest.mark.firmware_upgrade + def test_firmware_upgrade_request(self, upgrade_firmware, instantiate_testrail, instantiate_project, test_cases): + print() + if not upgrade_firmware: + instantiate_testrail.update_testrail(case_id=test_cases["upgrade_api"], run_id=instantiate_project, + status_id=0, + msg='Error requesting upgrade via API') + PASS = False + else: + instantiate_testrail.update_testrail(case_id=test_cases["upgrade_api"], run_id=instantiate_project, + status_id=1, + msg='Upgrade request using API successful') + PASS = True + assert PASS + + @pytest.mark.check_active_firmware_cloud + def test_active_version_cloud(self, get_latest_firmware, check_ap_firmware_cloud, instantiate_testrail, + instantiate_project, test_cases): + if get_latest_firmware != check_ap_firmware_cloud: + instantiate_testrail.update_testrail(case_id=test_cases["cloud_fw"], run_id=instantiate_project, + status_id=5, + msg='CLOUDSDK reporting incorrect firmware version.') + else: + instantiate_testrail.update_testrail(case_id=test_cases["cloud_fw"], run_id=instantiate_project, + status_id=1, + msg='CLOUDSDK reporting correct firmware version.') + + assert get_latest_firmware == check_ap_firmware_cloud + + +@pytest.mark.sanity +@pytest.mark.bridge +@pytest.mark.nat +@pytest.mark.vlan +@pytest.mark.check_active_firmware_ap +def test_ap_firmware(check_ap_firmware_ssh, get_latest_firmware, instantiate_testrail, instantiate_project, + test_cases): + if check_ap_firmware_ssh == get_latest_firmware: + instantiate_testrail.update_testrail(case_id=test_cases["ap_upgrade"], run_id=instantiate_project, + status_id=1, + msg='Upgrade to ' + get_latest_firmware + ' successful') + else: + instantiate_testrail.update_testrail(case_id=test_cases["ap_upgrade"], run_id=instantiate_project, + status_id=4, + msg='Cannot reach AP after upgrade to check CLI - re-test required') + + assert check_ap_firmware_ssh == get_latest_firmware diff --git a/tests/e2e/basic/client_connectivity_test/nat/basic_security_modes/__init__.py b/tests/e2e/basic/validation_of_operating_modes/__init__.py similarity index 100% rename from tests/e2e/basic/client_connectivity_test/nat/basic_security_modes/__init__.py rename to tests/e2e/basic/validation_of_operating_modes/__init__.py diff --git a/tests/e2e/basic/client_connectivity_test/nat/enterprise_security_modes/__init__.py b/tests/e2e/basic/validation_of_operating_modes/bridge_mode/__init__.py similarity index 100% rename from tests/e2e/basic/client_connectivity_test/nat/enterprise_security_modes/__init__.py rename to tests/e2e/basic/validation_of_operating_modes/bridge_mode/__init__.py diff --git a/tests/e2e/basic/client_connectivity_test/vlan/__init__.py b/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/__init__.py similarity index 100% rename from tests/e2e/basic/client_connectivity_test/vlan/__init__.py rename to tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/__init__.py diff --git a/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py b/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py new file mode 100644 index 000000000..15a5ce5bd --- /dev/null +++ b/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py @@ -0,0 +1,266 @@ +import allure +import pytest + +pytestmark = [pytest.mark.client_connectivity, pytest.mark.bridge] + +setup_params_general = { + "mode": "BRIDGE", + "ssid_modes": { + "open": [{"ssid_name": "ssid_open_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_open_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], + "wpa": [{"ssid_name": "ssid_wpa_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa2_personal": [ + {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}]}, + "rf": {}, + "radius": False +} + + +@pytest.mark.basic +@allure.feature("BRIDGE MODE CLIENT CONNECTIVITY") +@pytest.mark.parametrize( + 'setup_profiles', + [setup_params_general], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_profiles") +class TestBridgeModeConnectivity(object): + + @pytest.mark.configuration + def test_basic_configuration(self): + assert True + + @pytest.mark.open + @pytest.mark.twog + @allure.story('open 2.4 GHZ Band') + def test_open_ssid_2g(self, request, setup_profiles, get_lanforge_data, lf_test, update_report, test_cases): + profile_data = setup_params_general["ssid_modes"]["open"][0] + ssid_name = profile_data["ssid_name"] + security_key = "[BLANK]" + security = "open" + station_names = [] + for i in range(0, int(request.config.getini("num_stations"))): + station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) + mode = "BRIDGE" + band = "twog" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + @pytest.mark.open + @pytest.mark.fiveg + @allure.story('open 5 GHZ Band') + def test_open_ssid_5g(self, request, get_lanforge_data, lf_test, test_cases, update_report): + profile_data = setup_params_general["ssid_modes"]["open"][1] + ssid_name = profile_data["ssid_name"] + security_key = "[BLANK]" + security = "open" + station_names = [] + for i in range(0, int(request.config.getini("num_stations"))): + station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) + mode = "BRIDGE" + band = "fiveg" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + @pytest.mark.wpa + @pytest.mark.twog + @allure.story('wpa 2.4 GHZ Band') + def test_wpa_ssid_2g(self, request, get_lanforge_data, update_report, + lf_test, test_cases): + profile_data = setup_params_general["ssid_modes"]["wpa"][0] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa" + station_names = [] + for i in range(0, int(request.config.getini("num_stations"))): + station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) + mode = "BRIDGE" + band = "twog" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + @pytest.mark.wpa + @pytest.mark.fiveg + @allure.story('wpa 5 GHZ Band') + def test_wpa_ssid_5g(self, request, lf_test, update_report, test_cases, get_lanforge_data): + profile_data = setup_params_general["ssid_modes"]["wpa"][1] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa" + station_names = [] + for i in range(0, int(request.config.getini("num_stations"))): + station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) + mode = "BRIDGE" + band = "fiveg" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + @pytest.mark.wpa2_personal + @pytest.mark.twog + @allure.story('wpa2_personal 2.4 GHZ Band') + def test_wpa2_personal_ssid_2g(self, request, get_lanforge_data, lf_test, update_report, test_cases): + profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][0] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa2" + station_names = [] + for i in range(0, int(request.config.getini("num_stations"))): + station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) + mode = "BRIDGE" + band = "twog" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + @pytest.mark.wpa2_personal + @pytest.mark.fiveg + @allure.story('wpa2_personal 5 GHZ Band') + def test_wpa2_personal_ssid_5g(self, request, get_lanforge_data, update_report, test_cases, lf_test): + profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][1] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa2" + station_names = [] + for i in range(0, int(request.config.getini("num_stations"))): + station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) + mode = "BRIDGE" + band = "fiveg" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + +setup_params_enterprise = { + "mode": "BRIDGE", + "ssid_modes": { + "wpa2_enterprise": [ + {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa3_enterprise": [ + {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, + + "rf": {}, + "radius": True +} + + +@pytest.mark.enterprise +@pytest.mark.parametrize( + 'setup_profiles', + [setup_params_enterprise], + indirect=True, + scope="package" +) +@pytest.mark.usefixtures("setup_profiles") +class TestBridgeModeEnterprise(object): + + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + def test_wpa2_enterprise_2g(self, ): + # print(setup_client_connectivity) + assert "setup_client_connectivity" + + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + def test_wpa2_enterprise_5g(self): + assert "setup_client_connectivity" + + @pytest.mark.wpa3_enterprise + @pytest.mark.twog + def test_wpa3_enterprise_2g(self): + # print(setup_client_connectivity) + assert "setup_client_connectivity" + + @pytest.mark.wpa3_enterprise + @pytest.mark.fiveg + def test_wpa3_enterprise_5g(self): + assert "setup_client_connectivity" diff --git a/tests/e2e/basic/client_connectivity_test/vlan/basic_security_modes/__init__.py b/tests/e2e/basic/validation_of_operating_modes/nat_mode/__init__.py similarity index 100% rename from tests/e2e/basic/client_connectivity_test/vlan/basic_security_modes/__init__.py rename to tests/e2e/basic/validation_of_operating_modes/nat_mode/__init__.py diff --git a/tests/e2e/basic/client_connectivity_test/vlan/enterprise_security_modes/__init__.py b/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/__init__.py similarity index 100% rename from tests/e2e/basic/client_connectivity_test/vlan/enterprise_security_modes/__init__.py rename to tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/__init__.py diff --git a/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_basic_security.py b/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_basic_security.py new file mode 100644 index 000000000..2434b2d3a --- /dev/null +++ b/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_basic_security.py @@ -0,0 +1,260 @@ +import pytest +import allure + +pytestmark = [pytest.mark.client_connectivity, pytest.mark.nat] + +setup_params_general = { + "mode": "NAT", + "ssid_modes": { + "open": [{"ssid_name": "ssid_open_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_open_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], + "wpa": [{"ssid_name": "ssid_wpa_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa2_personal": [ + {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}]}, + "rf": {}, + "radius": False +} + + +@allure.feature("NAT MODE CLIENT CONNECTIVITY") +@pytest.mark.parametrize( + 'setup_profiles', + [setup_params_general], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_profiles") +class TestNATModeConnectivity(object): + + @pytest.mark.open + @pytest.mark.twog + @allure.story('open 2.4 GHZ Band') + def test_open_ssid_2g(self, request, setup_profiles, get_lanforge_data, lf_test, update_report, test_cases): + profile_data = setup_params_general["ssid_modes"]["open"][0] + ssid_name = profile_data["ssid_name"] + security_key = "[BLANK]" + security = "open" + station_names = [] + for i in range(0, int(request.config.getini("num_stations"))): + station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) + mode = "NAT" + band = "twog" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + @pytest.mark.open + @pytest.mark.fiveg + @allure.story('open 5 GHZ Band') + def test_open_ssid_5g(self, request, get_lanforge_data, lf_test, test_cases, update_report): + profile_data = setup_params_general["ssid_modes"]["open"][1] + ssid_name = profile_data["ssid_name"] + security_key = "[BLANK]" + security = "open" + station_names = [] + for i in range(0, int(request.config.getini("num_stations"))): + station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) + mode = "NAT" + band = "fiveg" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + @pytest.mark.wpa + @pytest.mark.twog + @allure.story('wpa 2.4 GHZ Band') + def test_wpa_ssid_2g(self, request, get_lanforge_data, update_report, + lf_test, test_cases): + profile_data = setup_params_general["ssid_modes"]["wpa"][0] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa" + station_names = [] + for i in range(0, int(request.config.getini("num_stations"))): + station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) + mode = "NAT" + band = "twog" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + @pytest.mark.wpa + @pytest.mark.fiveg + @allure.story('wpa 5 GHZ Band') + def test_wpa_ssid_5g(self, request, lf_test, update_report, test_cases, get_lanforge_data): + profile_data = setup_params_general["ssid_modes"]["wpa"][1] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa" + station_names = [] + for i in range(0, int(request.config.getini("num_stations"))): + station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) + mode = "NAT" + band = "fiveg" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + @pytest.mark.wpa2_personal + @pytest.mark.twog + @allure.story('wpa2_personal 2.4 GHZ Band') + def test_wpa2_personal_ssid_2g(self, request, get_lanforge_data, lf_test, update_report, test_cases): + profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][0] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa2" + station_names = [] + for i in range(0, int(request.config.getini("num_stations"))): + station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) + mode = "NAT" + band = "twog" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + @pytest.mark.wpa2_personal + @pytest.mark.fiveg + @allure.story('wpa2_personal 5 GHZ Band') + def test_wpa2_personal_ssid_5g(self, request, get_lanforge_data, update_report, test_cases, lf_test): + profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][1] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa2" + station_names = [] + for i in range(0, int(request.config.getini("num_stations"))): + station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) + mode = "NAT" + band = "fiveg" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + +setup_params_enterprise = { + "mode": "NAT", + "ssid_modes": { + "wpa2_enterprise": [ + {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa3_enterprise": [ + {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, + + "rf": {}, + "radius": True +} + + +@pytest.mark.parametrize( + 'setup_profiles', + [setup_params_enterprise], + indirect=True, + scope="package" +) +@pytest.mark.usefixtures("setup_profiles") +class TestNATModeEnterprise(object): + + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + def test_wpa2_enterprise_2g(self): + # print(setup_client_connectivity) + assert "setup_client_connectivity" + + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + def test_wpa2_enterprise_5g(self): + assert "setup_client_connectivity" + + @pytest.mark.wpa3_enterprise + @pytest.mark.twog + def test_wpa3_enterprise_2g(self): + # print(setup_client_connectivity) + assert "setup_client_connectivity" + + @pytest.mark.wpa3_enterprise + @pytest.mark.fiveg + def test_wpa3_enterprise_5g(self): + assert "setup_client_connectivity" diff --git a/tests/e2e/basic/dataplane_throughput_test/__init__.py b/tests/e2e/basic/validation_of_operating_modes/vlan_mode/__init__.py similarity index 100% rename from tests/e2e/basic/dataplane_throughput_test/__init__.py rename to tests/e2e/basic/validation_of_operating_modes/vlan_mode/__init__.py diff --git a/tests/e2e/basic/dual_band_performance_test/__init__.py b/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/__init__.py similarity index 100% rename from tests/e2e/basic/dual_band_performance_test/__init__.py rename to tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/__init__.py diff --git a/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_basic_security.py b/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_basic_security.py new file mode 100644 index 000000000..189d008b8 --- /dev/null +++ b/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_basic_security.py @@ -0,0 +1,261 @@ +import pytest +import allure + +pytestmark = [pytest.mark.client_connectivity, pytest.mark.vlan] + +setup_params_general = { + "mode": "VLAN", + "ssid_modes": { + "open": [{"ssid_name": "ssid_open_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_open_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], + "wpa": [{"ssid_name": "ssid_wpa_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa2_personal": [ + {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}]}, + "rf": {}, + "radius": False +} + + +@allure.feature("VLAN MODE CLIENT CONNECTIVITY") +@pytest.mark.parametrize( + 'setup_profiles', + [setup_params_general], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_profiles") +class TestVLANModeConnectivity(object): + + @pytest.mark.open + @pytest.mark.twog + @allure.story('open 2.4 GHZ Band') + def test_open_ssid_2g(self, request, get_lanforge_data, lf_test, update_report, test_cases): + profile_data = setup_params_general["ssid_modes"]["open"][0] + ssid_name = profile_data["ssid_name"] + security_key = "[BLANK]" + security = "open" + station_names = [] + for i in range(0, int(request.config.getini("num_stations"))): + station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) + mode = "VLAN" + band = "twog" + vlan = 100 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + @pytest.mark.open + @pytest.mark.fiveg + @allure.story('open 5 GHZ Band') + def test_open_ssid_5g(self, request, get_lanforge_data, lf_test, test_cases, update_report): + profile_data = setup_params_general["ssid_modes"]["open"][1] + ssid_name = profile_data["ssid_name"] + security_key = "[BLANK]" + security = "open" + station_names = [] + for i in range(0, int(request.config.getini("num_stations"))): + station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) + mode = "VLAN" + band = "fiveg" + vlan = 100 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + @pytest.mark.wpa + @pytest.mark.twog + @allure.story('wpa 2.4 GHZ Band') + def test_wpa_ssid_2g(self, request, get_lanforge_data, update_report, + lf_test, test_cases): + profile_data = setup_params_general["ssid_modes"]["wpa"][0] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa" + station_names = [] + for i in range(0, int(request.config.getini("num_stations"))): + station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) + mode = "VLAN" + band = "twog" + vlan = 100 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + @pytest.mark.wpa + @pytest.mark.fiveg + @allure.story('wpa 5 GHZ Band') + def test_wpa_ssid_5g(self, request, lf_test, update_report, test_cases, get_lanforge_data): + profile_data = setup_params_general["ssid_modes"]["wpa"][1] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa" + station_names = [] + for i in range(0, int(request.config.getini("num_stations"))): + station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) + mode = "VLAN" + band = "fiveg" + vlan = 100 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + @pytest.mark.wpa2_personal + @pytest.mark.twog + @allure.story('wpa2_personal 2.4 GHZ Band') + def test_wpa2_personal_ssid_2g(self, request, get_lanforge_data, lf_test, update_report, test_cases): + profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][0] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa2" + station_names = [] + for i in range(0, int(request.config.getini("num_stations"))): + station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) + mode = "VLAN" + band = "twog" + vlan = 100 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + @pytest.mark.wpa2_personal + @pytest.mark.fiveg + @allure.story('wpa2_personal 5 GHZ Band') + def test_wpa2_personal_ssid_5g(self, request, get_lanforge_data, update_report, test_cases, lf_test): + profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][1] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa2" + station_names = [] + for i in range(0, int(request.config.getini("num_stations"))): + station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) + mode = "VLAN" + band = "fiveg" + vlan = 100 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + +# setup_params_enterprise = { +# "mode": "BRIDGE", +# "ssid_modes": { +# "wpa2_enterprise": [ +# {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, +# {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], +# "security_key": "something"}], +# "wpa3_enterprise": [ +# {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, +# {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, +# +# "rf": {}, +# "radius": True +# } +# +# +# @pytest.mark.parametrize( +# 'setup_profiles', +# +# [setup_params_enterprise], +# indirect=True, +# scope="package" +# ) +# @pytest.mark.usefixtures("setup_profiles") +# class TestBridgeModeEnterprise(object): +# +# @pytest.mark.wpa2_enterprise +# @pytest.mark.twog +# def test_wpa2_enterprise_2g(self, ): +# # print(setup_client_connectivity) +# assert "setup_client_connectivity" +# +# @pytest.mark.wpa2_enterprise +# @pytest.mark.fiveg +# def test_wpa2_enterprise_5g(self): +# assert "setup_client_connectivity" +# +# @pytest.mark.wpa3_enterprise +# @pytest.mark.twog +# def test_wpa3_enterprise_2g(self): +# # print(setup_client_connectivity) +# assert "setup_client_connectivity" +# +# @pytest.mark.wpa3_enterprise +# @pytest.mark.fiveg +# def test_wpa3_enterprise_5g(self): +# assert "setup_client_connectivity" diff --git a/tests/e2e/basic/wifi_capacity_test/__init__.py b/tests/e2e/basic/validation_of_operating_modes/vlan_mode/default_vlan_tests/__init__.py similarity index 100% rename from tests/e2e/basic/wifi_capacity_test/__init__.py rename to tests/e2e/basic/validation_of_operating_modes/vlan_mode/default_vlan_tests/__init__.py diff --git a/tests/test_connectivity.py b/tests/test_connectivity.py index 5c0472034..8f6e2422f 100644 --- a/tests/test_connectivity.py +++ b/tests/test_connectivity.py @@ -1,65 +1,49 @@ """ Test Case Module: Testing Basic Connectivity with Resources - Mode: BRIDGE - """ -import pytest import sys -pytestmark = [pytest.mark.test_connectivity] +import allure +import pytest + +pytestmark = [pytest.mark.test_resources] @pytest.mark.sanity -@pytest.mark.bridge -@pytest.mark.nat -@pytest.mark.vlan -@pytest.mark.test_controller_connectivity -def test_controller_connectivity(instantiate_controller, instantiate_testrail, instantiate_project, test_cases): - try: - instantiate_testrail.update_testrail(case_id=test_cases["cloud_ver"], run_id=instantiate_project, - status_id=1, msg='Read CloudSDK version from API successfully') - PASS = True - except: - instantiate_testrail.update_testrail(case_id=test_cases["cloud_ver"], run_id=instantiate_project, - status_id=0, msg='Could not read CloudSDK version from API') - PASS = False - assert instantiate_controller +@allure.testcase(name="Test Resources", url="") +class TestResources(object): + @pytest.mark.test_cloud_controller + @allure.testcase(name="test_controller_connectivity", url="") + def test_controller_connectivity(self, setup_controller, update_report, test_cases): + if setup_controller.bearer: + allure.attach(name="Controller Connectivity Success", body="") + update_report.update_testrail(case_id=test_cases["cloud_ver"], + status_id=1, msg='Read CloudSDK version from API successfully') + else: + allure.attach(name="Controller Connectivity Failed", body="") + update_report.update_testrail(case_id=test_cases["cloud_ver"], + status_id=0, msg='Could not read CloudSDK version from API') + pytest.exit("Resource Not Available") + print(setup_controller.bearer) + assert setup_controller.bearer -@pytest.mark.sanity -@pytest.mark.bridge -@pytest.mark.nat -@pytest.mark.vlan -@pytest.mark.test_access_points_connectivity -def test_access_points_connectivity(test_access_point, instantiate_testrail, instantiate_project, test_cases): - if "ACTIVE" not in test_access_point: - instantiate_testrail.update_testrail(case_id=test_cases["cloud_connection"], run_id=instantiate_project, - status_id=5, - msg='CloudSDK connectivity failed') - status = False - sys.exit() - else: - instantiate_testrail.update_testrail(case_id=test_cases["cloud_connection"], run_id=instantiate_project, - status_id=1, - msg='Manager status is Active') - status = True - - assert status - - -@pytest.mark.sanity -@pytest.mark.bridge -@pytest.mark.nat -@pytest.mark.vlan -@pytest.mark.test_lanforge_connectivity -def test_lanforge_connectivity(check_lanforge_connectivity): - assert "instantiate_cloudsdk" - - -@pytest.mark.shivam -@pytest.mark.bridge -@pytest.mark.nat -@pytest.mark.vlan -@pytest.mark.test_perfecto_connectivity -def test_perfecto_connectivity(setup_controller): - assert "instantiate_cloudsdk" + @pytest.mark.test_access_points_connectivity + @allure.testcase(name="test_access_points_connectivity", url="") + def test_access_points_connectivity(self, test_access_point, update_report, test_cases): + print(test_access_point) + # if "ACTIVE" not in test_access_point: + # allure.attach(name="Access Point Connectivity Success", body=str(test_access_point)) + # update_report.update_testrail(case_id=test_cases["cloud_connection"], + # status_id=5, + # msg='CloudSDK connectivity failed') + # + # sys.exit() + # else: + # allure.attach(name="Access Point Connectivity Failed", body=str(test_access_point)) + # update_report.update_testrail(case_id=test_cases["cloud_connection"], + # status_id=1, + # msg='Manager status is Active') + # + # assert "ACTIVE" in test_access_point + assert True From 859eb4a56eaa12e7ca6f60995055febfadec0e80 Mon Sep 17 00:00:00 2001 From: shivamcandela Date: Fri, 14 May 2021 15:09:12 +0530 Subject: [PATCH 05/21] test case fixes Signed-off-by: shivamcandela --- tests/test_connectivity.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_connectivity.py b/tests/test_connectivity.py index e3f1e94b8..cb55cf949 100644 --- a/tests/test_connectivity.py +++ b/tests/test_connectivity.py @@ -43,7 +43,7 @@ def test_access_points_connectivity(test_access_point, instantiate_testrail, ins @pytest.mark.test_lanforge_connectivity def test_lanforge_connectivity(check_lanforge_connectivity): - assert "instantiate_cloudsdk" + assert check_lanforge_connectivity @pytest.mark.test_perfecto_connectivity From b340fe0ea7c9d6eaee61ac488c7f6809c8404d64 Mon Sep 17 00:00:00 2001 From: shivamcandela Date: Sat, 15 May 2021 01:58:37 +0530 Subject: [PATCH 06/21] CV Minor fixes --- tests/conftest.py | 4 +-- tests/e2e/basic/conftest.py | 60 +++++++++++++++++++++---------------- tests/test_connectivity.py | 7 +++-- 3 files changed, 41 insertions(+), 30 deletions(-) diff --git a/tests/conftest.py b/tests/conftest.py index e97df46a2..a3125cc89 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -364,5 +364,5 @@ def radius_info(): @pytest.fixture(scope="session") -def get_configuration(): - yield CONFIGURATION +def get_configuration(testbed): + yield CONFIGURATION[testbed] diff --git a/tests/e2e/basic/conftest.py b/tests/e2e/basic/conftest.py index e6eff35c2..eea926408 100644 --- a/tests/e2e/basic/conftest.py +++ b/tests/e2e/basic/conftest.py @@ -41,7 +41,6 @@ from LANforge.LFUtils import * if 'py-json' not in sys.path: sys.path.append('../py-scripts') - sys.path.append( os.path.dirname( os.path.realpath(__file__) @@ -67,7 +66,6 @@ from cv_test_manager import cv_test from create_chamberview import CreateChamberview from create_chamberview_dut import DUT - """ Basic Setup Collector """ @@ -335,45 +333,55 @@ def update_ssid(request, instantiate_profile, setup_profile_data): time.sleep(90) yield status -@pytest.fixture(scope="package") -def create_lanforge_chamberview(get_lanforge_data): - ip = get_lanforge_data["lanforge_ip"] - port = get_lanforge_data["lanforge-port-number"] - upstream_port = get_lanforge_data["lanforge_bridge_port"]#eth2 - eth_vlan = get_lanforge_data["lanforge_vlan_port"]#eth2.100 - vlan = get_lanforge_data["vlan"] - scenario_name = "TIP-test" +@pytest.fixture(scope="package") +def create_lanforge_chamberview(create_lanforge_chamberview_dut, get_configuration, testbed): + lanforge_data = get_configuration['traffic_generator']['details'] + ip = lanforge_data["ip"] + port = lanforge_data["port"] + upstream_port = lanforge_data["upstream"] # eth1 + uplink_port = lanforge_data["uplink"] # eth2 + upstream_subnet = lanforge_data["upstream_subnet"] + scenario_name = "TIP-" + testbed + upstream_res = upstream_port.split(".")[0] + "." + upstream_port.split(".")[1] + uplink_res = uplink_port.split(".")[0] + "." + uplink_port.split(".")[1] print(ip) - print(upstream_port) - print(eth_vlan) - print(vlan) + print(upstream_port, upstream_res, upstream_port.split(".")[2]) # "profile_link 1.1 upstream-dhcp 1 NA NA eth2,AUTO -1 NA" # "profile_link 1.1 uplink-nat 1 'DUT: upstream LAN 10.28.2.1/24' NA eth1,eth2 -1 NA" raw_line = [ - ["profile_link 1.1 upstream-dhcp 1 NA NA "+ upstream_port +",AUTO -1 NA"] - # ["profile_link 1.1 uplink-nat 1 'DUT: upstream LAN 10.28.2.1/24' NA eth1,eth2 -1 NA"] - ] + ["profile_link " + upstream_res + " upstream-dhcp 1 NA NA " + upstream_port.split(".")[2] + ",AUTO -1 NA"] + , ["profile_link " + uplink_res + " uplink-nat 1 'DUT: upstream LAN " + + upstream_subnet + "' NA " + uplink_port.split(".")[2] + " -1 NA"] + ] + print(raw_line) Create_Chamberview = CreateChamberview(ip, port) + Create_Chamberview.clean_cv_scenario() Create_Chamberview.clean_cv_scenario(type="Network-Connectivity", scenario_name=scenario_name) - Create_Chamberview.setup_scenario(create_scenario=scenario_name, + Create_Chamberview.setup(create_scenario=scenario_name, raw_line=raw_line) - Create_Chamberview.build_scenario(scenario_name) - Create_Chamberview.show_text_blob(None, None, True) # Show changes on GUI + Create_Chamberview.build(scenario_name) + Create_Chamberview.show_text_blob(None, None, True) # Show changes on GUI yield Create_Chamberview @pytest.fixture(scope="package") -def create_lanforge_chamberview_dut(get_lanforge_data): - ip = get_lanforge_data["lanforge_ip"] - port = get_lanforge_data["lanforge-port-number"] +def create_lanforge_chamberview_dut(get_configuration, testbed): + ap_model = get_configuration["access_point"][0]["model"] + version = get_configuration["access_point"][0]["version"] + serial = get_configuration["access_point"][0]["serial"] + # ap_model = get_configuration["access_point"][0]["model"] + lanforge_data = get_configuration['traffic_generator']['details'] + ip = lanforge_data["ip"] + port = lanforge_data["port"] dut = DUT(lfmgr=ip, port=port, - dut_name="TIP-Test", - sw_version="pending-d89798e", - hw_version="ECW5410", - model_num="ECW5410" + dut_name=testbed, + sw_version=version, + model_num=ap_model, + serial_num=serial ) + dut.setup() yield dut diff --git a/tests/test_connectivity.py b/tests/test_connectivity.py index 30420cca6..72fb25158 100644 --- a/tests/test_connectivity.py +++ b/tests/test_connectivity.py @@ -31,7 +31,8 @@ def test_controller_connectivity(instantiate_controller, instantiate_testrail, i @pytest.mark.nat @pytest.mark.vlan @pytest.mark.test_access_points_connectivity -def test_access_points_connectivity(access_point_connectivity, instantiate_testrail, instantiate_project, test_cases, exit_on_fail): +def test_access_points_connectivity(access_point_connectivity, instantiate_testrail, instantiate_project, test_cases, + exit_on_fail): if not access_point_connectivity["serial"] and not access_point_connectivity["mgr"]: instantiate_testrail.update_testrail(case_id=test_cases["cloud_connection"], run_id=instantiate_project, status_id=5, @@ -47,4 +48,6 @@ def test_access_points_connectivity(access_point_connectivity, instantiate_testr assert status - +@pytest.mark.test_lanforge_connectivity +def test_lanforge_connectiity(check_lanforge_connectivity): + assert True From 492c7181baa149c8b864dae0e3286adbf1618ca6 Mon Sep 17 00:00:00 2001 From: shivamcandela Date: Sat, 15 May 2021 02:01:06 +0530 Subject: [PATCH 07/21] configuration file updates Signed-off-by: shivamcandela --- tests/configuration.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/tests/configuration.py b/tests/configuration.py index 34332b49d..cfe43ffd0 100644 --- a/tests/configuration.py +++ b/tests/configuration.py @@ -104,7 +104,9 @@ CONFIGURATION = { "2.4G-Radio": ["wiphy0"], "5G-Radio": ["wiphy1"], "AX-Radio": ["wiphy2"], - "upstream": "eth1", + "upstream": "1.1.eth1", + "uplink": "1.1.eth2", + "upstream_subnet": "192.168.200.1/24", "2.4G-Station-Name": "wlan0", "5G-Station-Name": "wlan1", "AX-Station-Name": "ax", From 7d7d726142229b0085bd1fc5cd8928a4559c8d45 Mon Sep 17 00:00:00 2001 From: shivamcandela Date: Sat, 15 May 2021 11:28:43 +0530 Subject: [PATCH 08/21] Restruectured test cases Signed-off-by: shivamcandela --- .../_basic_test_setup/setup__e2e_resources.py | 81 ----- .../_basic_test_setup/setup_e2e_bridge.py | 174 ---------- .../basic/_basic_test_setup/setup_e2e_nat.py | 174 ---------- .../basic/_basic_test_setup/setup_e2e_vlan.py | 177 ----------- .../bridge_mode}/__init__.py | 0 .../test_bridge_mode_configuration.py | 298 ++++++++++++++++++ .../configuration_tests/nat_mode/__init__.py | 0 .../nat_mode/test_nat_mode_configuration.py | 298 ++++++++++++++++++ .../configuration_tests/vlan_mode/__init__.py | 0 .../vlan_mode/test_vlan_mode_configuration.py | 298 ++++++++++++++++++ tests/e2e/basic/test_firmware.py | 8 +- .../test_security_modes.py | 6 +- 12 files changed, 899 insertions(+), 615 deletions(-) delete mode 100644 tests/e2e/basic/_basic_test_setup/setup__e2e_resources.py delete mode 100644 tests/e2e/basic/_basic_test_setup/setup_e2e_bridge.py delete mode 100644 tests/e2e/basic/_basic_test_setup/setup_e2e_nat.py delete mode 100644 tests/e2e/basic/_basic_test_setup/setup_e2e_vlan.py rename tests/e2e/basic/{_basic_test_setup => configuration_tests/bridge_mode}/__init__.py (100%) create mode 100644 tests/e2e/basic/configuration_tests/bridge_mode/test_bridge_mode_configuration.py create mode 100644 tests/e2e/basic/configuration_tests/nat_mode/__init__.py create mode 100644 tests/e2e/basic/configuration_tests/nat_mode/test_nat_mode_configuration.py create mode 100644 tests/e2e/basic/configuration_tests/vlan_mode/__init__.py create mode 100644 tests/e2e/basic/configuration_tests/vlan_mode/test_vlan_mode_configuration.py diff --git a/tests/e2e/basic/_basic_test_setup/setup__e2e_resources.py b/tests/e2e/basic/_basic_test_setup/setup__e2e_resources.py deleted file mode 100644 index 6a3a1e554..000000000 --- a/tests/e2e/basic/_basic_test_setup/setup__e2e_resources.py +++ /dev/null @@ -1,81 +0,0 @@ -# """ -# Test Case Module: setup test cases for basic test cases -# Details: Firmware Upgrade -# -# """ -# import pytest -# -# @pytest.mark.configure_lanforge -# def test_configure_lanforge(configure_lanforge): -# -# assert True -# -# -# @pytest.mark.sanity -# @pytest.mark.bridge -# @pytest.mark.nat -# @pytest.mark.vlan -# @pytest.mark.firmware -# class TestFirmware(object): -# -# @pytest.mark.firmware_create -# def test_firmware_create(self, upload_firmware, instantiate_testrail, instantiate_project, test_cases): -# if upload_firmware != 0: -# instantiate_testrail.update_testrail(case_id=test_cases["create_fw"], run_id=instantiate_project, -# status_id=1, -# msg='Create new FW version by API successful') -# PASS = True -# else: -# instantiate_testrail.update_testrail(case_id=test_cases["create_fw"], run_id=instantiate_project, -# status_id=5, -# msg='Error creating new FW version by API') -# PASS = False -# assert PASS -# -# @pytest.mark.firmware_upgrade -# def test_firmware_upgrade_request(self, upgrade_firmware, instantiate_testrail, instantiate_project, test_cases): -# print() -# if not upgrade_firmware: -# instantiate_testrail.update_testrail(case_id=test_cases["upgrade_api"], run_id=instantiate_project, -# status_id=0, -# msg='Error requesting upgrade via API') -# PASS = False -# else: -# instantiate_testrail.update_testrail(case_id=test_cases["upgrade_api"], run_id=instantiate_project, -# status_id=1, -# msg='Upgrade request using API successful') -# PASS = True -# assert PASS -# -# @pytest.mark.check_active_firmware_cloud -# def test_active_version_cloud(self, get_latest_firmware, check_ap_firmware_cloud, instantiate_testrail, -# instantiate_project, test_cases): -# if get_latest_firmware != check_ap_firmware_cloud: -# instantiate_testrail.update_testrail(case_id=test_cases["cloud_fw"], run_id=instantiate_project, -# status_id=5, -# msg='CLOUDSDK reporting incorrect firmware version.') -# else: -# instantiate_testrail.update_testrail(case_id=test_cases["cloud_fw"], run_id=instantiate_project, -# status_id=1, -# msg='CLOUDSDK reporting correct firmware version.') -# -# assert get_latest_firmware == check_ap_firmware_cloud -# -# -# @pytest.mark.sanity -# @pytest.mark.bridge -# @pytest.mark.nat -# @pytest.mark.vlan -# @pytest.mark.check_active_firmware_ap -# def test_ap_firmware(check_ap_firmware_ssh, get_latest_firmware, instantiate_testrail, instantiate_project, -# test_cases): -# if check_ap_firmware_ssh == get_latest_firmware: -# instantiate_testrail.update_testrail(case_id=test_cases["ap_upgrade"], run_id=instantiate_project, -# status_id=1, -# msg='Upgrade to ' + get_latest_firmware + ' successful') -# else: -# instantiate_testrail.update_testrail(case_id=test_cases["ap_upgrade"], run_id=instantiate_project, -# status_id=4, -# msg='Cannot reach AP after upgrade to check CLI - re-test required') -# -# assert check_ap_firmware_ssh == get_latest_firmware diff --git a/tests/e2e/basic/_basic_test_setup/setup_e2e_bridge.py b/tests/e2e/basic/_basic_test_setup/setup_e2e_bridge.py deleted file mode 100644 index 044e72cb5..000000000 --- a/tests/e2e/basic/_basic_test_setup/setup_e2e_bridge.py +++ /dev/null @@ -1,174 +0,0 @@ -""" - Test Case Module: setup test cases for bridge mode sanity - Details: bridge mode setup - -""" -import time - -import pytest - - -@pytest.mark.sanity -@pytest.mark.setup_bridge -@pytest.mark.bridge -@pytest.mark.parametrize( - 'setup_profiles, create_profiles', - [(["BRIDGE"], ["BRIDGE"])], - indirect=True, - scope="class" -) -@pytest.mark.usefixtures("setup_profiles") -@pytest.mark.usefixtures("create_profiles") -class TestSetupBridge: - - @pytest.mark.wpa - @pytest.mark.twog - def test_setup_wpa_2g_ssid_profile(self, create_profiles, instantiate_testrail, instantiate_project, test_cases): - if create_profiles['ssid_2g_wpa_bridge']: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_2g_wpa_bridge"], run_id=instantiate_project, - status_id=1, - msg='profile created successfully') - assert create_profiles['ssid_2g_wpa_bridge'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_2g_wpa_bridge"], run_id=instantiate_project, - status_id=5, - msg='Failed to create profile') - assert False - - @pytest.mark.wpa - @pytest.mark.fiveg - def test_setup_wpa_5g_ssid_profile(self, create_profiles, instantiate_testrail, instantiate_project, test_cases): - - if create_profiles['ssid_5g_wpa_bridge']: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_5g_wpa_bridge"], run_id=instantiate_project, - status_id=1, - msg='profile created successfully') - assert create_profiles['ssid_5g_wpa_bridge'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_5g_wpa_bridge"], run_id=instantiate_project, - status_id=5, - msg='Failed to create profile') - assert False - - @pytest.mark.wpa2_personal - @pytest.mark.twog - def test_setup_wpa2_personal_2g_ssid_profile(self, create_profiles, instantiate_testrail, instantiate_project, - test_cases): - - if create_profiles['ssid_2g_wpa2_bridge']: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_2g_wpa2_bridge"], run_id=instantiate_project, - status_id=1, - msg='profile created successfully') - assert create_profiles['ssid_2g_wpa2_bridge'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_2g_wpa2_bridge"], run_id=instantiate_project, - status_id=5, - msg='Failed to create profile') - assert False - - @pytest.mark.wpa2_personal - @pytest.mark.fiveg - def test_setup_wpa2_personal_5g_ssid_profile(self, create_profiles, instantiate_testrail, instantiate_project, - test_cases): - - if create_profiles['ssid_5g_wpa2_bridge']: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_5g_wpa2_bridge"], run_id=instantiate_project, - status_id=1, - msg='profile created successfully') - assert create_profiles['ssid_5g_wpa2_bridge'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_5g_wpa2_bridge"], run_id=instantiate_project, - status_id=5, - msg='Failed to create profile') - assert False - - @pytest.mark.radius - def test_setup_radius_profile(self, create_profiles, instantiate_testrail, instantiate_project, test_cases): - - if create_profiles['radius_profile']: - instantiate_testrail.update_testrail(case_id=test_cases["radius_profile"], run_id=instantiate_project, - status_id=1, - msg='profile created successfully') - assert create_profiles['radius_profile'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["radius_profile"], run_id=instantiate_project, - status_id=5, - msg='Failed to create profile') - assert False - - @pytest.mark.wpa2_enterprise - @pytest.mark.twog - @pytest.mark.radius - def test_setup_wpa2_enterprise_2g_ssid_profile(self, create_profiles, instantiate_testrail, instantiate_project, - test_cases): - - if create_profiles['ssid_2g_eap_bridge']: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_2g_eap_bridge"], run_id=instantiate_project, - status_id=1, - msg='profile created successfully') - assert create_profiles['ssid_2g_eap_bridge'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_2g_eap_bridge"], run_id=instantiate_project, - status_id=5, - msg='Failed to create profile') - assert False - - @pytest.mark.wpa2_enterprise - @pytest.mark.fiveg - @pytest.mark.radius - def test_setup_wpa2_enterprise_5g_ssid_profile(self, create_profiles, instantiate_testrail, instantiate_project, - test_cases): - - if create_profiles['ssid_5g_eap_bridge']: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_5g_eap_bridge"], run_id=instantiate_project, - status_id=1, - msg='profile created successfully') - assert create_profiles['ssid_5g_eap_bridge'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_5g_eap_bridge"], run_id=instantiate_project, - status_id=5, - msg='Failed to create profile') - assert False - - def test_setup_equipment_ap_profile(self, create_profiles, instantiate_testrail, instantiate_project, - test_cases): - - if create_profiles['ap_bridge']: - instantiate_testrail.update_testrail(case_id=test_cases["ap_bridge"], run_id=instantiate_project, - status_id=1, - msg='profile created successfully') - assert create_profiles['ap_bridge'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["ap_bridge"], run_id=instantiate_project, - status_id=5, - msg='Failed to create profile') - assert False - - def test_verify_vif_config(self, setup_profiles, instantiate_testrail, instantiate_project, - test_cases): - - if setup_profiles['bridge_vifc']: - instantiate_testrail.update_testrail(case_id=test_cases["bridge_vifc"], run_id=instantiate_project, - status_id=1, - msg='profile pushed successfully') - assert setup_profiles['bridge_vifc'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["bridge_vifc"], run_id=instantiate_project, - status_id=5, - msg='Failed to push profile') - assert False - - def test_verify_vif_state(self, setup_profiles, instantiate_testrail, instantiate_project, - test_cases): - if setup_profiles['bridge_vifs']: - instantiate_testrail.update_testrail(case_id=test_cases["bridge_vifs"], run_id=instantiate_project, - status_id=1, - msg='profile pushed successfully') - time.sleep(100) - assert setup_profiles['bridge_vifs'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["bridge_vifs"], run_id=instantiate_project, - status_id=5, - msg='Failed to push profile') - time.sleep(100) - assert False diff --git a/tests/e2e/basic/_basic_test_setup/setup_e2e_nat.py b/tests/e2e/basic/_basic_test_setup/setup_e2e_nat.py deleted file mode 100644 index 9f60ca2f4..000000000 --- a/tests/e2e/basic/_basic_test_setup/setup_e2e_nat.py +++ /dev/null @@ -1,174 +0,0 @@ -""" - Test Case Module: setup test cases for nat mode sanity - Details: nat mode setup - -""" -import time - -import pytest - - -@pytest.mark.sanity -@pytest.mark.setup_nat -@pytest.mark.nat -@pytest.mark.parametrize( - 'setup_profiles, create_profiles', - [(["NAT"], ["NAT"])], - indirect=True, - scope="class" -) -@pytest.mark.usefixtures("setup_profiles") -@pytest.mark.usefixtures("create_profiles") -class TestSetupnat: - - @pytest.mark.wpa - @pytest.mark.twog - def test_setup_wpa_2g_ssid_profile(self, create_profiles, instantiate_testrail, instantiate_project, test_cases): - if create_profiles['ssid_2g_wpa_nat']: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_2g_wpa_nat"], run_id=instantiate_project, - status_id=1, - msg='profile created successfully') - assert create_profiles['ssid_2g_wpa_nat'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_2g_wpa_nat"], run_id=instantiate_project, - status_id=5, - msg='Failed to create profile') - assert False - - @pytest.mark.wpa - @pytest.mark.fiveg - def test_setup_wpa_5g_ssid_profile(self, create_profiles, instantiate_testrail, instantiate_project, test_cases): - - if create_profiles['ssid_5g_wpa_nat']: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_5g_wpa_nat"], run_id=instantiate_project, - status_id=1, - msg='profile created successfully') - assert create_profiles['ssid_5g_wpa_nat'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_5g_wpa_nat"], run_id=instantiate_project, - status_id=5, - msg='Failed to create profile') - assert False - - @pytest.mark.wpa2_personal - @pytest.mark.twog - def test_setup_wpa2_personal_2g_ssid_profile(self, create_profiles, instantiate_testrail, instantiate_project, - test_cases): - - if create_profiles['ssid_2g_wpa2_nat']: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_2g_wpa2_nat"], run_id=instantiate_project, - status_id=1, - msg='profile created successfully') - assert create_profiles['ssid_2g_wpa2_nat'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_2g_wpa2_nat"], run_id=instantiate_project, - status_id=5, - msg='Failed to create profile') - assert False - - @pytest.mark.wpa2_personal - @pytest.mark.fiveg - def test_setup_wpa2_personal_5g_ssid_profile(self, create_profiles, instantiate_testrail, instantiate_project, - test_cases): - - if create_profiles['ssid_5g_wpa2_nat']: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_5g_wpa2_nat"], run_id=instantiate_project, - status_id=1, - msg='profile created successfully') - assert create_profiles['ssid_5g_wpa2_nat'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_5g_wpa2_nat"], run_id=instantiate_project, - status_id=5, - msg='Failed to create profile') - assert False - - @pytest.mark.radius - def test_setup_radius_profile(self, create_profiles, instantiate_testrail, instantiate_project, test_cases): - - if create_profiles['radius_profile']: - instantiate_testrail.update_testrail(case_id=test_cases["radius_profile"], run_id=instantiate_project, - status_id=1, - msg='profile created successfully') - assert create_profiles['radius_profile'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["radius_profile"], run_id=instantiate_project, - status_id=5, - msg='Failed to create profile') - assert False - - @pytest.mark.wpa2_enterprise - @pytest.mark.twog - @pytest.mark.radius - def test_setup_wpa2_enterprise_2g_ssid_profile(self, create_profiles, instantiate_testrail, instantiate_project, - test_cases): - - if create_profiles['ssid_2g_eap_nat']: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_2g_eap_nat"], run_id=instantiate_project, - status_id=1, - msg='profile created successfully') - assert create_profiles['ssid_2g_eap_nat'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_2g_eap_nat"], run_id=instantiate_project, - status_id=5, - msg='Failed to create profile') - assert False - - @pytest.mark.wpa2_enterprise - @pytest.mark.fiveg - @pytest.mark.radius - def test_setup_wpa2_enterprise_5g_ssid_profile(self, create_profiles, instantiate_testrail, instantiate_project, - test_cases): - - if create_profiles['ssid_5g_eap_nat']: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_5g_eap_nat"], run_id=instantiate_project, - status_id=1, - msg='profile created successfully') - assert create_profiles['ssid_5g_eap_nat'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_5g_eap_nat"], run_id=instantiate_project, - status_id=5, - msg='Failed to create profile') - assert False - - def test_setup_equipment_ap_profile(self, create_profiles, instantiate_testrail, instantiate_project, - test_cases): - - if create_profiles['ap_nat']: - instantiate_testrail.update_testrail(case_id=test_cases["ap_nat"], run_id=instantiate_project, - status_id=1, - msg='profile created successfully') - assert create_profiles['ap_nat'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["ap_nat"], run_id=instantiate_project, - status_id=5, - msg='Failed to create profile') - assert False - - def test_verify_vif_config(self, setup_profiles, instantiate_testrail, instantiate_project, - test_cases): - - if setup_profiles['nat_vifc']: - instantiate_testrail.update_testrail(case_id=test_cases["nat_vifc"], run_id=instantiate_project, - status_id=1, - msg='profile pushed successfully') - assert setup_profiles['nat_vifc'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["nat_vifc"], run_id=instantiate_project, - status_id=5, - msg='Failed to push profile') - assert False - - def test_verify_vif_state(self, setup_profiles, instantiate_testrail, instantiate_project, - test_cases): - if setup_profiles['nat_vifs']: - instantiate_testrail.update_testrail(case_id=test_cases["nat_vifs"], run_id=instantiate_project, - status_id=1, - msg='profile pushed successfully') - time.sleep(100) - assert setup_profiles['nat_vifs'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["nat_vifs"], run_id=instantiate_project, - status_id=5, - msg='Failed to push profile') - time.sleep(100) - assert False diff --git a/tests/e2e/basic/_basic_test_setup/setup_e2e_vlan.py b/tests/e2e/basic/_basic_test_setup/setup_e2e_vlan.py deleted file mode 100644 index e3a814b28..000000000 --- a/tests/e2e/basic/_basic_test_setup/setup_e2e_vlan.py +++ /dev/null @@ -1,177 +0,0 @@ -""" - Test Case Module: setup test cases for vlan mode sanity - Details: vlan mode setup - -""" -import time - -import pytest - - -@pytest.mark.sanity -@pytest.mark.setup_vlan -@pytest.mark.vlan -@pytest.mark.parametrize( - 'setup_profiles, create_profiles', - [(["VLAN"], ["VLAN"])], - indirect=True, - scope="class" -) -@pytest.mark.usefixtures("setup_profiles") -@pytest.mark.usefixtures("create_profiles") -class TestSetupvlan: - - - @pytest.mark.wpa - @pytest.mark.twog - def test_setup_wpa_2g_ssid_profile(self, create_profiles, instantiate_testrail, instantiate_project, test_cases): - if create_profiles['ssid_2g_wpa_vlan']: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_2g_wpa_vlan"], run_id=instantiate_project, - status_id=1, - msg='profile created successfully') - assert create_profiles['ssid_2g_wpa_vlan'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_2g_wpa_vlan"], run_id=instantiate_project, - status_id=5, - msg='Failed to create profile') - assert False - - @pytest.mark.wpa - @pytest.mark.fiveg - def test_setup_wpa_5g_ssid_profile(self, create_profiles, instantiate_testrail, instantiate_project, test_cases): - - if create_profiles['ssid_5g_wpa_vlan']: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_5g_wpa_vlan"], run_id=instantiate_project, - status_id=1, - msg='profile created successfully') - assert create_profiles['ssid_5g_wpa_vlan'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_5g_wpa_vlan"], run_id=instantiate_project, - status_id=5, - msg='Failed to create profile') - assert False - - @pytest.mark.wpa2_personal - @pytest.mark.twog - def test_setup_wpa2_personal_2g_ssid_profile(self, create_profiles, instantiate_testrail, instantiate_project, - test_cases): - - if create_profiles['ssid_2g_wpa2_vlan']: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_2g_wpa2_vlan"], run_id=instantiate_project, - status_id=1, - msg='profile created successfully') - assert create_profiles['ssid_2g_wpa2_vlan'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_2g_wpa2_vlan"], run_id=instantiate_project, - status_id=5, - msg='Failed to create profile') - assert False - - @pytest.mark.wpa2_personal - @pytest.mark.fiveg - def test_setup_wpa2_personal_5g_ssid_profile(self, create_profiles, instantiate_testrail, instantiate_project, - test_cases): - - if create_profiles['ssid_5g_wpa2_vlan']: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_5g_wpa2_vlan"], run_id=instantiate_project, - status_id=1, - msg='profile created successfully') - assert create_profiles['ssid_5g_wpa2_vlan'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_5g_wpa2_vlan"], run_id=instantiate_project, - status_id=5, - msg='Failed to create profile') - assert False - - @pytest.mark.radius - def test_setup_radius_profile(self, create_profiles, instantiate_testrail, instantiate_project, test_cases): - - if create_profiles['radius_profile']: - instantiate_testrail.update_testrail(case_id=test_cases["radius_profile"], run_id=instantiate_project, - status_id=1, - msg='profile created successfully') - assert create_profiles['radius_profile'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["radius_profile"], run_id=instantiate_project, - status_id=5, - msg='Failed to create profile') - assert False - - @pytest.mark.wpa2_enterprise - @pytest.mark.twog - @pytest.mark.radius - def test_setup_wpa2_enterprise_2g_ssid_profile(self, create_profiles, instantiate_testrail, instantiate_project, - test_cases): - - if create_profiles['ssid_2g_eap_vlan']: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_2g_eap_vlan"], run_id=instantiate_project, - status_id=1, - msg='profile created successfully') - assert create_profiles['ssid_2g_eap_vlan'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_2g_eap_vlan"], run_id=instantiate_project, - status_id=5, - msg='Failed to create profile') - assert False - - @pytest.mark.wpa2_enterprise - @pytest.mark.fiveg - @pytest.mark.radius - def test_setup_wpa2_enterprise_5g_ssid_profile(self, create_profiles, instantiate_testrail, instantiate_project, - test_cases): - - if create_profiles['ssid_5g_eap_vlan']: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_5g_eap_vlan"], run_id=instantiate_project, - status_id=1, - msg='profile created successfully') - assert create_profiles['ssid_5g_eap_vlan'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["ssid_5g_eap_vlan"], run_id=instantiate_project, - status_id=5, - msg='Failed to create profile') - assert False - - def test_setup_equipment_ap_profile(self, create_profiles, instantiate_testrail, instantiate_project, - test_cases): - - if create_profiles['ap_vlan']: - instantiate_testrail.update_testrail(case_id=test_cases["ap_vlan"], run_id=instantiate_project, - status_id=1, - msg='profile created successfully') - assert create_profiles['ap_vlan'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["ap_vlan"], run_id=instantiate_project, - status_id=5, - msg='Failed to create profile') - assert False - - def test_verify_vif_config(self, setup_profiles, instantiate_testrail, instantiate_project, - test_cases): - - if setup_profiles['vlan_vifc']: - instantiate_testrail.update_testrail(case_id=test_cases["vlan_vifc"], run_id=instantiate_project, - status_id=1, - msg='profile pushed successfully') - assert setup_profiles['vlan_vifc'] - else: - instantiate_testrail.update_testrail(case_id=test_cases["vlan_vifc"], run_id=instantiate_project, - status_id=5, - msg='Failed to push profile') - assert False - - def test_verify_vif_state(self, setup_profiles, instantiate_testrail, instantiate_project, - test_cases): - if setup_profiles['vlan_vifs']: - instantiate_testrail.update_testrail(case_id=test_cases["vlan_vifs"], run_id=instantiate_project, - status_id=1, - msg='profile pushed successfully') - time.sleep(100) - - assert setup_profiles['vlan_vifs'] - - else: - instantiate_testrail.update_testrail(case_id=test_cases["vlan_vifs"], run_id=instantiate_project, - status_id=5, - msg='Failed to push profile') - time.sleep(100) - assert False diff --git a/tests/e2e/basic/_basic_test_setup/__init__.py b/tests/e2e/basic/configuration_tests/bridge_mode/__init__.py similarity index 100% rename from tests/e2e/basic/_basic_test_setup/__init__.py rename to tests/e2e/basic/configuration_tests/bridge_mode/__init__.py diff --git a/tests/e2e/basic/configuration_tests/bridge_mode/test_bridge_mode_configuration.py b/tests/e2e/basic/configuration_tests/bridge_mode/test_bridge_mode_configuration.py new file mode 100644 index 000000000..7b73cb585 --- /dev/null +++ b/tests/e2e/basic/configuration_tests/bridge_mode/test_bridge_mode_configuration.py @@ -0,0 +1,298 @@ +import allure +import pytest +import time + +pytestmark = [pytest.mark.client_connectivity, pytest.mark.bridge] + +setup_params_general = { + "mode": "BRIDGE", + "ssid_modes": { + "open": [{"ssid_name": "ssid_open_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_open_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], + "wpa": [{"ssid_name": "ssid_wpa_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa2_personal": [ + {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}]}, + "rf": {}, + "radius": False +} + + +@pytest.mark.basic +@allure.feature("BRIDGE MODE SETUP") +@pytest.mark.parametrize( + 'setup_profiles', + [setup_params_general], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_profiles") +class TestSetupBridge(object): + + @pytest.mark.open + @pytest.mark.twog + def test_setup_wpa_2g_ssid_profile(self, setup_profiles, update_report, test_cases): + if setup_profiles['open_2g']: + update_report.update_testrail(case_id=test_cases["open_2g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['open_2g'] + else: + update_report.update_testrail(case_id=test_cases["open_2g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.open + @pytest.mark.fiveg + def test_setup_wpa_5g_ssid_profile(self, setup_profiles, update_report, test_cases): + + if setup_profiles['open_5g']: + update_report.update_testrail(case_id=test_cases["open_5g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['open_5g'] + else: + update_report.update_testrail(case_id=test_cases["open_5g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa + @pytest.mark.twog + def test_setup_wpa_2g_ssid_profile(self, setup_profiles, update_report, test_cases): + if setup_profiles['wpa_2g']: + update_report.update_testrail(case_id=test_cases["wpa_2g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa_2g'] + else: + update_report.update_testrail(case_id=test_cases["wpa_2g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa + @pytest.mark.fiveg + def test_setup_wpa_5g_ssid_profile(self, setup_profiles, update_report, test_cases): + + if setup_profiles['wpa_5g']: + update_report.update_testrail(case_id=test_cases["wpa_5g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa_5g'] + else: + update_report.update_testrail(case_id=test_cases["wpa_5g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa2_personal + @pytest.mark.twog + def test_setup_wpa2_personal_2g_ssid_profile(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['wpa2_personal_2g']: + update_report.update_testrail(case_id=test_cases["wpa2_personal_2g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa2_personal_2g'] + else: + update_report.update_testrail(case_id=test_cases["wpa2_personal_2g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa2_personal + @pytest.mark.fiveg + def test_setup_wpa2_personal_5g_ssid_profile(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['wpa2_personal_5g']: + update_report.update_testrail(case_id=test_cases["wpa2_personal_5g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa2_personal_5g'] + else: + update_report.update_testrail(case_id=test_cases["wpa2_personal_5g"], + status_id=5, + msg='Failed to create profile') + assert False + + def test_setup_equipment_ap_profile(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['equipment_ap']: + update_report.update_testrail(case_id=test_cases["equipment_ap"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['equipment_ap'] + else: + update_report.update_testrail(case_id=test_cases["equipment_ap"], + status_id=5, + msg='Failed to create profile') + assert False + + def test_verify_vif_config(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['vifc']: + update_report.update_testrail(case_id=test_cases["vifc"], + status_id=1, + msg='profile pushed successfully') + assert setup_profiles['vifc'] + else: + update_report.update_testrail(case_id=test_cases["vifc"], + status_id=5, + msg='Failed to push profile') + assert False + + def test_verify_vif_state(self, setup_profiles, update_report, + test_cases): + if setup_profiles['vifs']: + update_report.update_testrail(case_id=test_cases["vifs"], + status_id=1, + msg='profile pushed successfully') + time.sleep(100) + assert setup_profiles['vifs'] + else: + update_report.update_testrail(case_id=test_cases["vifs"], + status_id=5, + msg='Failed to push profile') + time.sleep(100) + assert False + + +setup_params_enterprise = { + "mode": "BRIDGE", + "ssid_modes": { + "wpa2_enterprise": [ + {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa3_enterprise": [ + {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, + + "rf": {}, + "radius": True +} + + +@pytest.mark.enterprise +@allure.feature("BRIDGE MODE ENTERPRISE SETUP") +@pytest.mark.parametrize( + 'setup_profiles', + [setup_params_enterprise], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_profiles") +class TestSetupBridgeEnterprise(object): + + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + def test_setup_wpa2_enterprise_2g_ssid_profile(self, setup_profiles, update_report, test_cases): + if setup_profiles['wpa2_enterprise_2g']: + update_report.update_testrail(case_id=test_cases["wpa2_enterprise_2g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa2_enterprise_2g'] + else: + update_report.update_testrail(case_id=test_cases["wpa2_enterprise_2g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + def test_setup_wpa2_enterprise_5g_ssid_profile(self, setup_profiles, update_report, test_cases): + + if setup_profiles['wpa2_enterprise_5g']: + update_report.update_testrail(case_id=test_cases["wpa2_enterprise_5g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa2_enterprise_5g'] + else: + update_report.update_testrail(case_id=test_cases["wpa2_enterprise_5g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa3_enterprise + @pytest.mark.twog + def test_setup_wpa3_enterprise_2g_ssid_profile(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['wpa3_enterprise_2g']: + update_report.update_testrail(case_id=test_cases["wpa3_enterprise_2g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa3_enterprise_2g'] + else: + update_report.update_testrail(case_id=test_cases["wpa3_enterprise_2g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa3_enterprise + @pytest.mark.fiveg + def test_setup_wpa3_enterprise_5g_ssid_profile(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['wpa3_enterprise_5g']: + update_report.update_testrail(case_id=test_cases["wpa3_enterprise_5g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa3_enterprise_5g'] + else: + update_report.update_testrail(case_id=test_cases["wpa3_enterprise_5g"], + status_id=5, + msg='Failed to create profile') + assert False + + def test_setup_equipment_ap_profile(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['equipment_ap']: + update_report.update_testrail(case_id=test_cases["equipment_ap"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['equipment_ap'] + else: + update_report.update_testrail(case_id=test_cases["equipment_ap"], + status_id=5, + msg='Failed to create profile') + assert False + + def test_verify_vif_config(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['vifc']: + update_report.update_testrail(case_id=test_cases["vifc"], + status_id=1, + msg='profile pushed successfully') + assert setup_profiles['vifc'] + else: + update_report.update_testrail(case_id=test_cases["vifc"], + status_id=5, + msg='Failed to push profile') + assert False + + def test_verify_vif_state(self, setup_profiles, update_report, + test_cases): + if setup_profiles['vifs']: + update_report.update_testrail(case_id=test_cases["vifs"], + status_id=1, + msg='profile pushed successfully') + time.sleep(100) + assert setup_profiles['vifs'] + else: + update_report.update_testrail(case_id=test_cases["vifs"], + status_id=5, + msg='Failed to push profile') + time.sleep(100) + assert False diff --git a/tests/e2e/basic/configuration_tests/nat_mode/__init__.py b/tests/e2e/basic/configuration_tests/nat_mode/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/e2e/basic/configuration_tests/nat_mode/test_nat_mode_configuration.py b/tests/e2e/basic/configuration_tests/nat_mode/test_nat_mode_configuration.py new file mode 100644 index 000000000..a8cef9c00 --- /dev/null +++ b/tests/e2e/basic/configuration_tests/nat_mode/test_nat_mode_configuration.py @@ -0,0 +1,298 @@ +import allure +import pytest +import time + +pytestmark = [pytest.mark.client_connectivity, pytest.mark.bridge] + +setup_params_general = { + "mode": "NAT", + "ssid_modes": { + "open": [{"ssid_name": "ssid_open_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_open_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], + "wpa": [{"ssid_name": "ssid_wpa_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa2_personal": [ + {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}]}, + "rf": {}, + "radius": False +} + + +@pytest.mark.basic +@allure.feature("BRIDGE MODE SETUP") +@pytest.mark.parametrize( + 'setup_profiles', + [setup_params_general], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_profiles") +class TestSetupNAT(object): + + @pytest.mark.open + @pytest.mark.twog + def test_setup_wpa_2g_ssid_profile(self, setup_profiles, update_report, test_cases): + if setup_profiles['open_2g']: + update_report.update_testrail(case_id=test_cases["open_2g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['open_2g'] + else: + update_report.update_testrail(case_id=test_cases["open_2g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.open + @pytest.mark.fiveg + def test_setup_wpa_5g_ssid_profile(self, setup_profiles, update_report, test_cases): + + if setup_profiles['open_5g']: + update_report.update_testrail(case_id=test_cases["open_5g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['open_5g'] + else: + update_report.update_testrail(case_id=test_cases["open_5g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa + @pytest.mark.twog + def test_setup_wpa_2g_ssid_profile(self, setup_profiles, update_report, test_cases): + if setup_profiles['wpa_2g']: + update_report.update_testrail(case_id=test_cases["wpa_2g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa_2g'] + else: + update_report.update_testrail(case_id=test_cases["wpa_2g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa + @pytest.mark.fiveg + def test_setup_wpa_5g_ssid_profile(self, setup_profiles, update_report, test_cases): + + if setup_profiles['wpa_5g']: + update_report.update_testrail(case_id=test_cases["wpa_5g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa_5g'] + else: + update_report.update_testrail(case_id=test_cases["wpa_5g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa2_personal + @pytest.mark.twog + def test_setup_wpa2_personal_2g_ssid_profile(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['wpa2_personal_2g']: + update_report.update_testrail(case_id=test_cases["wpa2_personal_2g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa2_personal_2g'] + else: + update_report.update_testrail(case_id=test_cases["wpa2_personal_2g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa2_personal + @pytest.mark.fiveg + def test_setup_wpa2_personal_5g_ssid_profile(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['wpa2_personal_5g']: + update_report.update_testrail(case_id=test_cases["wpa2_personal_5g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa2_personal_5g'] + else: + update_report.update_testrail(case_id=test_cases["wpa2_personal_5g"], + status_id=5, + msg='Failed to create profile') + assert False + + def test_setup_equipment_ap_profile(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['equipment_ap']: + update_report.update_testrail(case_id=test_cases["equipment_ap"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['equipment_ap'] + else: + update_report.update_testrail(case_id=test_cases["equipment_ap"], + status_id=5, + msg='Failed to create profile') + assert False + + def test_verify_vif_config(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['vifc']: + update_report.update_testrail(case_id=test_cases["vifc"], + status_id=1, + msg='profile pushed successfully') + assert setup_profiles['vifc'] + else: + update_report.update_testrail(case_id=test_cases["vifc"], + status_id=5, + msg='Failed to push profile') + assert False + + def test_verify_vif_state(self, setup_profiles, update_report, + test_cases): + if setup_profiles['vifs']: + update_report.update_testrail(case_id=test_cases["vifs"], + status_id=1, + msg='profile pushed successfully') + time.sleep(100) + assert setup_profiles['vifs'] + else: + update_report.update_testrail(case_id=test_cases["vifs"], + status_id=5, + msg='Failed to push profile') + time.sleep(100) + assert False + + +setup_params_enterprise = { + "mode": "NAT", + "ssid_modes": { + "wpa2_enterprise": [ + {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa3_enterprise": [ + {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, + + "rf": {}, + "radius": True +} + + +@pytest.mark.enterprise +@allure.feature("NAT MODE ENTERPRISE SETUP") +@pytest.mark.parametrize( + 'setup_profiles', + [setup_params_enterprise], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_profiles") +class TestSetupNATEnterprise(object): + + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + def test_setup_wpa2_enterprise_2g_ssid_profile(self, setup_profiles, update_report, test_cases): + if setup_profiles['wpa2_enterprise_2g']: + update_report.update_testrail(case_id=test_cases["wpa2_enterprise_2g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa2_enterprise_2g'] + else: + update_report.update_testrail(case_id=test_cases["wpa2_enterprise_2g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + def test_setup_wpa2_enterprise_5g_ssid_profile(self, setup_profiles, update_report, test_cases): + + if setup_profiles['wpa2_enterprise_5g']: + update_report.update_testrail(case_id=test_cases["wpa2_enterprise_5g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa2_enterprise_5g'] + else: + update_report.update_testrail(case_id=test_cases["wpa2_enterprise_5g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa3_enterprise + @pytest.mark.twog + def test_setup_wpa3_enterprise_2g_ssid_profile(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['wpa3_enterprise_2g']: + update_report.update_testrail(case_id=test_cases["wpa3_enterprise_2g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa3_enterprise_2g'] + else: + update_report.update_testrail(case_id=test_cases["wpa3_enterprise_2g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa3_enterprise + @pytest.mark.fiveg + def test_setup_wpa3_enterprise_5g_ssid_profile(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['wpa3_enterprise_5g']: + update_report.update_testrail(case_id=test_cases["wpa3_enterprise_5g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa3_enterprise_5g'] + else: + update_report.update_testrail(case_id=test_cases["wpa3_enterprise_5g"], + status_id=5, + msg='Failed to create profile') + assert False + + def test_setup_equipment_ap_profile(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['equipment_ap']: + update_report.update_testrail(case_id=test_cases["equipment_ap"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['equipment_ap'] + else: + update_report.update_testrail(case_id=test_cases["equipment_ap"], + status_id=5, + msg='Failed to create profile') + assert False + + def test_verify_vif_config(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['vifc']: + update_report.update_testrail(case_id=test_cases["vifc"], + status_id=1, + msg='profile pushed successfully') + assert setup_profiles['vifc'] + else: + update_report.update_testrail(case_id=test_cases["vifc"], + status_id=5, + msg='Failed to push profile') + assert False + + def test_verify_vif_state(self, setup_profiles, update_report, + test_cases): + if setup_profiles['vifs']: + update_report.update_testrail(case_id=test_cases["vifs"], + status_id=1, + msg='profile pushed successfully') + time.sleep(100) + assert setup_profiles['vifs'] + else: + update_report.update_testrail(case_id=test_cases["vifs"], + status_id=5, + msg='Failed to push profile') + time.sleep(100) + assert False diff --git a/tests/e2e/basic/configuration_tests/vlan_mode/__init__.py b/tests/e2e/basic/configuration_tests/vlan_mode/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/e2e/basic/configuration_tests/vlan_mode/test_vlan_mode_configuration.py b/tests/e2e/basic/configuration_tests/vlan_mode/test_vlan_mode_configuration.py new file mode 100644 index 000000000..d27936d5e --- /dev/null +++ b/tests/e2e/basic/configuration_tests/vlan_mode/test_vlan_mode_configuration.py @@ -0,0 +1,298 @@ +import allure +import pytest +import time + +pytestmark = [pytest.mark.client_connectivity, pytest.mark.bridge] + +setup_params_general = { + "mode": "VLAN", + "ssid_modes": { + "open": [{"ssid_name": "ssid_open_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_open_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], + "wpa": [{"ssid_name": "ssid_wpa_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa2_personal": [ + {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}]}, + "rf": {}, + "radius": False +} + + +@pytest.mark.basic +@allure.feature("BRIDGE MODE SETUP") +@pytest.mark.parametrize( + 'setup_profiles', + [setup_params_general], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_profiles") +class TestSetupVlan(object): + + @pytest.mark.open + @pytest.mark.twog + def test_setup_wpa_2g_ssid_profile(self, setup_profiles, update_report, test_cases): + if setup_profiles['open_2g']: + update_report.update_testrail(case_id=test_cases["open_2g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['open_2g'] + else: + update_report.update_testrail(case_id=test_cases["open_2g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.open + @pytest.mark.fiveg + def test_setup_wpa_5g_ssid_profile(self, setup_profiles, update_report, test_cases): + + if setup_profiles['open_5g']: + update_report.update_testrail(case_id=test_cases["open_5g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['open_5g'] + else: + update_report.update_testrail(case_id=test_cases["open_5g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa + @pytest.mark.twog + def test_setup_wpa_2g_ssid_profile(self, setup_profiles, update_report, test_cases): + if setup_profiles['wpa_2g']: + update_report.update_testrail(case_id=test_cases["wpa_2g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa_2g'] + else: + update_report.update_testrail(case_id=test_cases["wpa_2g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa + @pytest.mark.fiveg + def test_setup_wpa_5g_ssid_profile(self, setup_profiles, update_report, test_cases): + + if setup_profiles['wpa_5g']: + update_report.update_testrail(case_id=test_cases["wpa_5g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa_5g'] + else: + update_report.update_testrail(case_id=test_cases["wpa_5g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa2_personal + @pytest.mark.twog + def test_setup_wpa2_personal_2g_ssid_profile(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['wpa2_personal_2g']: + update_report.update_testrail(case_id=test_cases["wpa2_personal_2g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa2_personal_2g'] + else: + update_report.update_testrail(case_id=test_cases["wpa2_personal_2g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa2_personal + @pytest.mark.fiveg + def test_setup_wpa2_personal_5g_ssid_profile(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['wpa2_personal_5g']: + update_report.update_testrail(case_id=test_cases["wpa2_personal_5g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa2_personal_5g'] + else: + update_report.update_testrail(case_id=test_cases["wpa2_personal_5g"], + status_id=5, + msg='Failed to create profile') + assert False + + def test_setup_equipment_ap_profile(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['equipment_ap']: + update_report.update_testrail(case_id=test_cases["equipment_ap"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['equipment_ap'] + else: + update_report.update_testrail(case_id=test_cases["equipment_ap"], + status_id=5, + msg='Failed to create profile') + assert False + + def test_verify_vif_config(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['vifc']: + update_report.update_testrail(case_id=test_cases["vifc"], + status_id=1, + msg='profile pushed successfully') + assert setup_profiles['vifc'] + else: + update_report.update_testrail(case_id=test_cases["vifc"], + status_id=5, + msg='Failed to push profile') + assert False + + def test_verify_vif_state(self, setup_profiles, update_report, + test_cases): + if setup_profiles['vifs']: + update_report.update_testrail(case_id=test_cases["vifs"], + status_id=1, + msg='profile pushed successfully') + time.sleep(100) + assert setup_profiles['vifs'] + else: + update_report.update_testrail(case_id=test_cases["vifs"], + status_id=5, + msg='Failed to push profile') + time.sleep(100) + assert False + + +setup_params_enterprise = { + "mode": "VLAN", + "ssid_modes": { + "wpa2_enterprise": [ + {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa3_enterprise": [ + {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, + + "rf": {}, + "radius": True +} + + +@pytest.mark.enterprise +@allure.feature("VLAN MODE ENTERPRISE SETUP") +@pytest.mark.parametrize( + 'setup_profiles', + [setup_params_enterprise], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_profiles") +class TestSetupVlanEnterprise(object): + + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + def test_setup_wpa2_enterprise_2g_ssid_profile(self, setup_profiles, update_report, test_cases): + if setup_profiles['wpa2_enterprise_2g']: + update_report.update_testrail(case_id=test_cases["wpa2_enterprise_2g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa2_enterprise_2g'] + else: + update_report.update_testrail(case_id=test_cases["wpa2_enterprise_2g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + def test_setup_wpa2_enterprise_5g_ssid_profile(self, setup_profiles, update_report, test_cases): + + if setup_profiles['wpa2_enterprise_5g']: + update_report.update_testrail(case_id=test_cases["wpa2_enterprise_5g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa2_enterprise_5g'] + else: + update_report.update_testrail(case_id=test_cases["wpa2_enterprise_5g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa3_enterprise + @pytest.mark.twog + def test_setup_wpa3_enterprise_2g_ssid_profile(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['wpa3_enterprise_2g']: + update_report.update_testrail(case_id=test_cases["wpa3_enterprise_2g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa3_enterprise_2g'] + else: + update_report.update_testrail(case_id=test_cases["wpa3_enterprise_2g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa3_enterprise + @pytest.mark.fiveg + def test_setup_wpa3_enterprise_5g_ssid_profile(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['wpa3_enterprise_5g']: + update_report.update_testrail(case_id=test_cases["wpa3_enterprise_5g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa3_enterprise_5g'] + else: + update_report.update_testrail(case_id=test_cases["wpa3_enterprise_5g"], + status_id=5, + msg='Failed to create profile') + assert False + + def test_setup_equipment_ap_profile(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['equipment_ap']: + update_report.update_testrail(case_id=test_cases["equipment_ap"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['equipment_ap'] + else: + update_report.update_testrail(case_id=test_cases["equipment_ap"], + status_id=5, + msg='Failed to create profile') + assert False + + def test_verify_vif_config(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['vifc']: + update_report.update_testrail(case_id=test_cases["vifc"], + status_id=1, + msg='profile pushed successfully') + assert setup_profiles['vifc'] + else: + update_report.update_testrail(case_id=test_cases["vifc"], + status_id=5, + msg='Failed to push profile') + assert False + + def test_verify_vif_state(self, setup_profiles, update_report, + test_cases): + if setup_profiles['vifs']: + update_report.update_testrail(case_id=test_cases["vifs"], + status_id=1, + msg='profile pushed successfully') + time.sleep(100) + assert setup_profiles['vifs'] + else: + update_report.update_testrail(case_id=test_cases["vifs"], + status_id=5, + msg='Failed to push profile') + time.sleep(100) + assert False diff --git a/tests/e2e/basic/test_firmware.py b/tests/e2e/basic/test_firmware.py index 8af8183d6..761c354a4 100644 --- a/tests/e2e/basic/test_firmware.py +++ b/tests/e2e/basic/test_firmware.py @@ -5,11 +5,11 @@ """ import pytest -@pytest.mark.configure_lanforge -def test_configure_lanforge(configure_lanforge): - - assert True +# @pytest.mark.configure_lanforge +# def test_configure_lanforge(configure_lanforge): +# assert True +# @pytest.mark.sanity @pytest.mark.bridge diff --git a/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py b/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py index 15a5ce5bd..d7a44b802 100644 --- a/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py +++ b/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py @@ -31,10 +31,6 @@ setup_params_general = { @pytest.mark.usefixtures("setup_profiles") class TestBridgeModeConnectivity(object): - @pytest.mark.configuration - def test_basic_configuration(self): - assert True - @pytest.mark.open @pytest.mark.twog @allure.story('open 2.4 GHZ Band') @@ -245,7 +241,7 @@ class TestBridgeModeEnterprise(object): @pytest.mark.wpa2_enterprise @pytest.mark.twog - def test_wpa2_enterprise_2g(self, ): + def test_wpa2_enterprise_2g(self): # print(setup_client_connectivity) assert "setup_client_connectivity" From 1e23a6b7c0465e28aa0fea4fd0efbffdac5f7d39 Mon Sep 17 00:00:00 2001 From: shivamcandela Date: Sat, 15 May 2021 11:40:37 +0530 Subject: [PATCH 09/21] updated sanity markers Signed-off-by: shivamcandela --- .../bridge_mode/test_bridge_mode_configuration.py | 2 +- .../nat_mode/test_nat_mode_configuration.py | 2 +- .../vlan_mode/test_vlan_mode_configuration.py | 2 +- tests/e2e/basic/test_firmware.py | 14 ++++---------- .../client_connectivity/test_security_modes.py | 2 +- .../client_connectivity/test_basic_security.py | 2 +- .../client_connectivity/test_basic_security.py | 2 +- 7 files changed, 10 insertions(+), 16 deletions(-) diff --git a/tests/e2e/basic/configuration_tests/bridge_mode/test_bridge_mode_configuration.py b/tests/e2e/basic/configuration_tests/bridge_mode/test_bridge_mode_configuration.py index 7b73cb585..2fafaca92 100644 --- a/tests/e2e/basic/configuration_tests/bridge_mode/test_bridge_mode_configuration.py +++ b/tests/e2e/basic/configuration_tests/bridge_mode/test_bridge_mode_configuration.py @@ -2,7 +2,7 @@ import allure import pytest import time -pytestmark = [pytest.mark.client_connectivity, pytest.mark.bridge] +pytestmark = [pytest.mark.setup, pytest.mark.bridge, pytest.mark.sanity] setup_params_general = { "mode": "BRIDGE", diff --git a/tests/e2e/basic/configuration_tests/nat_mode/test_nat_mode_configuration.py b/tests/e2e/basic/configuration_tests/nat_mode/test_nat_mode_configuration.py index a8cef9c00..aa5ce5b3a 100644 --- a/tests/e2e/basic/configuration_tests/nat_mode/test_nat_mode_configuration.py +++ b/tests/e2e/basic/configuration_tests/nat_mode/test_nat_mode_configuration.py @@ -2,7 +2,7 @@ import allure import pytest import time -pytestmark = [pytest.mark.client_connectivity, pytest.mark.bridge] +pytestmark = [pytest.mark.setup, pytest.mark.nat, pytest.mark.sanity] setup_params_general = { "mode": "NAT", diff --git a/tests/e2e/basic/configuration_tests/vlan_mode/test_vlan_mode_configuration.py b/tests/e2e/basic/configuration_tests/vlan_mode/test_vlan_mode_configuration.py index d27936d5e..9c61b3339 100644 --- a/tests/e2e/basic/configuration_tests/vlan_mode/test_vlan_mode_configuration.py +++ b/tests/e2e/basic/configuration_tests/vlan_mode/test_vlan_mode_configuration.py @@ -2,7 +2,7 @@ import allure import pytest import time -pytestmark = [pytest.mark.client_connectivity, pytest.mark.bridge] +pytestmark = [pytest.mark.setup, pytest.mark.vlan, pytest.mark.sanity] setup_params_general = { "mode": "VLAN", diff --git a/tests/e2e/basic/test_firmware.py b/tests/e2e/basic/test_firmware.py index 761c354a4..6074937b7 100644 --- a/tests/e2e/basic/test_firmware.py +++ b/tests/e2e/basic/test_firmware.py @@ -5,17 +5,15 @@ """ import pytest +pytestmark = [pytest.mark.firmware, pytest.mark.sanity] + # @pytest.mark.configure_lanforge # def test_configure_lanforge(configure_lanforge): # assert True # -@pytest.mark.sanity -@pytest.mark.bridge -@pytest.mark.nat -@pytest.mark.vlan -@pytest.mark.firmware +@pytest.mark.firmware_cloud class TestFirmware(object): @pytest.mark.firmware_create @@ -62,11 +60,7 @@ class TestFirmware(object): assert get_latest_firmware == check_ap_firmware_cloud -@pytest.mark.sanity -@pytest.mark.bridge -@pytest.mark.nat -@pytest.mark.vlan -@pytest.mark.check_active_firmware_ap +@pytest.mark.firmware_ap def test_ap_firmware(check_ap_firmware_ssh, get_latest_firmware, instantiate_testrail, instantiate_project, test_cases): if check_ap_firmware_ssh == get_latest_firmware: diff --git a/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py b/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py index d7a44b802..b33716045 100644 --- a/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py +++ b/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py @@ -1,7 +1,7 @@ import allure import pytest -pytestmark = [pytest.mark.client_connectivity, pytest.mark.bridge] +pytestmark = [pytest.mark.client_connectivity, pytest.mark.bridge, pytest.mark.sanity] setup_params_general = { "mode": "BRIDGE", diff --git a/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_basic_security.py b/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_basic_security.py index 2434b2d3a..0d33b2891 100644 --- a/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_basic_security.py +++ b/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_basic_security.py @@ -1,7 +1,7 @@ import pytest import allure -pytestmark = [pytest.mark.client_connectivity, pytest.mark.nat] +pytestmark = [pytest.mark.client_connectivity, pytest.mark.nat, pytest.mark.sanity] setup_params_general = { "mode": "NAT", diff --git a/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_basic_security.py b/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_basic_security.py index 189d008b8..753dbf6d7 100644 --- a/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_basic_security.py +++ b/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_basic_security.py @@ -1,7 +1,7 @@ import pytest import allure -pytestmark = [pytest.mark.client_connectivity, pytest.mark.vlan] +pytestmark = [pytest.mark.client_connectivity, pytest.mark.vlan, pytest.mark.sanity] setup_params_general = { "mode": "VLAN", From 8aad461270dd1367d43f2adb01c7061dd8f22d47 Mon Sep 17 00:00:00 2001 From: shivamcandela Date: Sat, 15 May 2021 16:40:03 +0530 Subject: [PATCH 10/21] resource check for multi ap support Signed-off-by: shivamcandela --- .../test_security_modes.py | 86 ++++++++----------- tests/test_connectivity.py | 36 ++++---- 2 files changed, 56 insertions(+), 66 deletions(-) diff --git a/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py b/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py index b33716045..449f00e38 100644 --- a/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py +++ b/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py @@ -34,81 +34,73 @@ class TestBridgeModeConnectivity(object): @pytest.mark.open @pytest.mark.twog @allure.story('open 2.4 GHZ Band') - def test_open_ssid_2g(self, request, setup_profiles, get_lanforge_data, lf_test, update_report, test_cases): + def test_open_ssid_2g(self, setup_profiles, get_lanforge_data, lf_test, update_report, station_names_twog, + test_cases): profile_data = setup_params_general["ssid_modes"]["open"][0] ssid_name = profile_data["ssid_name"] security_key = "[BLANK]" security = "open" - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) mode = "BRIDGE" band = "twog" vlan = 1 passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, passkey=security_key, mode=mode, band=band, - station_name=station_names, vlan_id=vlan) + station_name=station_names_twog, vlan_id=vlan) - if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], - status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( - passes)) - else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], - status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( - passes)) + # if result: + # update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + # status_id=1, + # msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + # passes)) + # else: + # update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + # status_id=5, + # msg='2G WPA Client Connectivity Failed - bridge mode' + str( + # passes)) assert result @pytest.mark.open @pytest.mark.fiveg @allure.story('open 5 GHZ Band') - def test_open_ssid_5g(self, request, get_lanforge_data, lf_test, test_cases, update_report): + def test_open_ssid_5g(self, get_lanforge_data, lf_test, test_cases, station_names_fiveg, update_report): profile_data = setup_params_general["ssid_modes"]["open"][1] ssid_name = profile_data["ssid_name"] security_key = "[BLANK]" security = "open" - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) mode = "BRIDGE" band = "fiveg" vlan = 1 passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, passkey=security_key, mode=mode, band=band, - station_name=station_names, vlan_id=vlan) + station_name=station_names_fiveg, vlan_id=vlan) - if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], - status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( - passes)) - else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], - status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( - passes)) + # if result: + # update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + # status_id=1, + # msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + # passes)) + # else: + # update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + # status_id=5, + # msg='2G WPA Client Connectivity Failed - bridge mode' + str( + # passes)) assert result @pytest.mark.wpa @pytest.mark.twog @allure.story('wpa 2.4 GHZ Band') def test_wpa_ssid_2g(self, request, get_lanforge_data, update_report, - lf_test, test_cases): + lf_test, test_cases, station_names_twog): profile_data = setup_params_general["ssid_modes"]["wpa"][0] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] security = "wpa" - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) mode = "BRIDGE" band = "twog" vlan = 1 passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, passkey=security_key, mode=mode, band=band, - station_name=station_names, vlan_id=vlan) + station_name=station_names_twog, vlan_id=vlan) if result: update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], @@ -125,20 +117,17 @@ class TestBridgeModeConnectivity(object): @pytest.mark.wpa @pytest.mark.fiveg @allure.story('wpa 5 GHZ Band') - def test_wpa_ssid_5g(self, request, lf_test, update_report, test_cases, get_lanforge_data): + def test_wpa_ssid_5g(self, lf_test, update_report, test_cases, station_names_fiveg, get_lanforge_data): profile_data = setup_params_general["ssid_modes"]["wpa"][1] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] security = "wpa" - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) mode = "BRIDGE" band = "fiveg" vlan = 1 passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, passkey=security_key, mode=mode, band=band, - station_name=station_names, vlan_id=vlan) + station_name=station_names_fiveg, vlan_id=vlan) if result: update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], @@ -155,20 +144,18 @@ class TestBridgeModeConnectivity(object): @pytest.mark.wpa2_personal @pytest.mark.twog @allure.story('wpa2_personal 2.4 GHZ Band') - def test_wpa2_personal_ssid_2g(self, request, get_lanforge_data, lf_test, update_report, test_cases): + def test_wpa2_personal_ssid_2g(self, get_lanforge_data, lf_test, update_report, test_cases, + station_names_twog): profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][0] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] security = "wpa2" - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) mode = "BRIDGE" band = "twog" vlan = 1 passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, passkey=security_key, mode=mode, band=band, - station_name=station_names, vlan_id=vlan) + station_name=station_names_twog, vlan_id=vlan) if result: update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], @@ -185,20 +172,18 @@ class TestBridgeModeConnectivity(object): @pytest.mark.wpa2_personal @pytest.mark.fiveg @allure.story('wpa2_personal 5 GHZ Band') - def test_wpa2_personal_ssid_5g(self, request, get_lanforge_data, update_report, test_cases, lf_test): + def test_wpa2_personal_ssid_5g(self, get_lanforge_data, update_report, test_cases, station_names_fiveg, + lf_test): profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][1] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] security = "wpa2" - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) mode = "BRIDGE" band = "fiveg" vlan = 1 passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, passkey=security_key, mode=mode, band=band, - station_name=station_names, vlan_id=vlan) + station_name=station_names_fiveg, vlan_id=vlan) if result: update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], @@ -260,3 +245,4 @@ class TestBridgeModeEnterprise(object): @pytest.mark.fiveg def test_wpa3_enterprise_5g(self): assert "setup_client_connectivity" + diff --git a/tests/test_connectivity.py b/tests/test_connectivity.py index 8f6e2422f..fca9337e2 100644 --- a/tests/test_connectivity.py +++ b/tests/test_connectivity.py @@ -31,19 +31,23 @@ class TestResources(object): @pytest.mark.test_access_points_connectivity @allure.testcase(name="test_access_points_connectivity", url="") def test_access_points_connectivity(self, test_access_point, update_report, test_cases): - print(test_access_point) - # if "ACTIVE" not in test_access_point: - # allure.attach(name="Access Point Connectivity Success", body=str(test_access_point)) - # update_report.update_testrail(case_id=test_cases["cloud_connection"], - # status_id=5, - # msg='CloudSDK connectivity failed') - # - # sys.exit() - # else: - # allure.attach(name="Access Point Connectivity Failed", body=str(test_access_point)) - # update_report.update_testrail(case_id=test_cases["cloud_connection"], - # status_id=1, - # msg='Manager status is Active') - # - # assert "ACTIVE" in test_access_point - assert True + flag = True + for i in test_access_point: + if "ACTIVE" not in i: + flag = False + + if flag is False: + allure.attach(name="Access Point Connectivity Success", body=str(test_access_point)) + update_report.update_testrail(case_id=test_cases["cloud_connection"], + status_id=5, + msg='CloudSDK connectivity failed') + + pytest.exit("Access Point Manafer state is not ACtive") + else: + allure.attach(name="Access Point Connectivity Failed", body=str(test_access_point)) + update_report.update_testrail(case_id=test_cases["cloud_connection"], + status_id=1, + msg='Manager status is Active') + + assert flag + From a548b2e1718f69b107c9131afec8e3ffdd645339 Mon Sep 17 00:00:00 2001 From: shivamcandela Date: Mon, 17 May 2021 13:12:38 +0530 Subject: [PATCH 11/21] library support for all security modes Signed-off-by: shivamcandela --- libs/apnos/apnos.py | 2 +- libs/controller/controller.py | 185 ++++++++++++++---- tests/conftest.py | 80 ++++++++ tests/e2e/basic/conftest.py | 36 ++-- tests/e2e/basic/test_firmware.py | 62 +++--- ...sic_security.py => test_security_modes.py} | 0 ...sic_security.py => test_security_modes.py} | 0 tests/test_connectivity.py | 1 + 8 files changed, 286 insertions(+), 80 deletions(-) rename tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/{test_basic_security.py => test_security_modes.py} (100%) rename tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/{test_basic_security.py => test_security_modes.py} (100%) diff --git a/libs/apnos/apnos.py b/libs/apnos/apnos.py index 84b20888f..a09a6d5c1 100644 --- a/libs/apnos/apnos.py +++ b/libs/apnos/apnos.py @@ -161,7 +161,7 @@ class APNOS: stdin, stdout, stderr = client.exec_command(cmd) output = stdout.read() status = str(output.decode('utf-8').splitlines()) - # print(output, stderr.read()) + print(output, stderr.read()) client.close() except Exception as e: print(e) diff --git a/libs/controller/controller.py b/libs/controller/controller.py index 34339cc4e..8070d2f62 100644 --- a/libs/controller/controller.py +++ b/libs/controller/controller.py @@ -143,7 +143,7 @@ class Controller(ConfigureController): print("Server not Reachable") exit() print("Connected to Controller Server") - # self.semaphore = False + # self.semaphore = False def portal_ping(self): return self.login_client.portal_ping() @@ -341,7 +341,7 @@ class ProfileUtility: self.default_profiles['radius'] = i if i._name == "TipWlan-rf": self.default_profiles['rf'] = i - + print(i) # This will delete the Profiles associated with an equipment of givwn equipment_id, and associate it to default # equipment_ap profile def delete_current_profile(self, equipment_id=None): @@ -441,6 +441,9 @@ class ProfileUtility: default_profile._details["rfConfigMap"]["is5GHz"]["rf"] = profile_data["name"] default_profile._details["rfConfigMap"]["is5GHzL"]["rf"] = profile_data["name"] default_profile._details["rfConfigMap"]["is5GHzU"]["rf"] = profile_data["name"] + # for i in profile_data['rfConfigMap']: + # for j in profile_data['rfConfigMap'][i]: + # default_profile._details["rfConfigMap"][i][j] = profile_data['rfConfigMap'][i][j] profile = self.profile_client.create_profile(body=default_profile) self.profile_creation_ids['rf'].append(profile._id) return profile @@ -466,6 +469,7 @@ class ProfileUtility: method call: used to create a ssid profile with the given parameters """ + # Open def create_open_ssid_profile(self, profile_data=None): try: if profile_data is None: @@ -488,6 +492,7 @@ class ProfileUtility: return profile + # wpa personal def create_wpa_ssid_profile(self, profile_data=None): try: if profile_data is None: @@ -509,6 +514,7 @@ class ProfileUtility: profile = False return profile + # wpa2 personal def create_wpa2_personal_ssid_profile(self, profile_data=None): try: if profile_data is None: @@ -531,6 +537,7 @@ class ProfileUtility: profile = False return profile + # wpa3 personal def create_wpa3_personal_ssid_profile(self, profile_data=None): try: if profile_data is None: @@ -543,7 +550,7 @@ class ProfileUtility: default_profile._details['ssid'] = profile_data['ssid_name'] default_profile._details['keyStr'] = profile_data['security_key'] default_profile._details['forwardMode'] = profile_data['mode'] - default_profile._details['secureMode'] = 'wpa3OnlyPSK' + default_profile._details['secureMode'] = 'wpa3OnlySAE' profile = self.profile_client.create_profile(body=default_profile) profile_id = profile._id self.profile_creation_ids['ssid'].append(profile_id) @@ -553,6 +560,101 @@ class ProfileUtility: profile = False return profile + # wpa3 personal mixed mode + def create_wpa3_personal_mixed_ssid_profile(self, profile_data=None): + try: + if profile_data is None: + return False + default_profile = self.default_profiles['ssid'] + default_profile._details['appliedRadios'] = profile_data["appliedRadios"] + + default_profile._name = profile_data['profile_name'] + default_profile._details['vlanId'] = profile_data['vlan'] + default_profile._details['ssid'] = profile_data['ssid_name'] + default_profile._details['keyStr'] = profile_data['security_key'] + default_profile._details['forwardMode'] = profile_data['mode'] + default_profile._details['secureMode'] = 'wpa3MixedSAE' + profile = self.profile_client.create_profile(body=default_profile) + profile_id = profile._id + self.profile_creation_ids['ssid'].append(profile_id) + self.profile_ids.append(profile_id) + except Exception as e: + print(e) + profile = False + return profile + + # wpa wpa3 personal mixed mode + def create_wpa_wpa2_personal_mixed_ssid_profile(self, profile_data=None): + try: + if profile_data is None: + return False + default_profile = self.default_profiles['ssid'] + default_profile._details['appliedRadios'] = profile_data["appliedRadios"] + + default_profile._name = profile_data['profile_name'] + default_profile._details['vlanId'] = profile_data['vlan'] + default_profile._details['ssid'] = profile_data['ssid_name'] + default_profile._details['keyStr'] = profile_data['security_key'] + default_profile._details['forwardMode'] = profile_data['mode'] + default_profile._details['secureMode'] = 'wpa2PSK' + profile = self.profile_client.create_profile(body=default_profile) + profile_id = profile._id + self.profile_creation_ids['ssid'].append(profile_id) + self.profile_ids.append(profile_id) + except Exception as e: + print(e) + profile = False + return profile + + # wpa enterprise + def create_wpa_enterprise_ssid_profile(self, profile_data=None): + try: + if profile_data is None: + return False + default_profile = self.default_profiles['ssid'] + default_profile._details['appliedRadios'] = profile_data["appliedRadios"] + + default_profile._name = profile_data['profile_name'] + default_profile._details['vlanId'] = profile_data['vlan'] + default_profile._details['ssid'] = profile_data['ssid_name'] + default_profile._details['forwardMode'] = profile_data['mode'] + default_profile._details["radiusServiceId"] = self.profile_creation_ids["radius"][0] + default_profile._child_profile_ids = self.profile_creation_ids["radius"] + default_profile._details['secureMode'] = 'wpaRadius' + profile = self.profile_client.create_profile(body=default_profile) + profile_id = profile._id + self.profile_creation_ids['ssid'].append(profile_id) + self.profile_ids.append(profile_id) + except Exception as e: + print(e) + profile = False + return profile + + # wpa wpa2 enterprise mixed mode + def create_wpa_wpa2_enterprise_mixed_ssid_profile(self, profile_data=None): + try: + if profile_data is None: + return False + default_profile = self.default_profiles['ssid'] + default_profile._details['appliedRadios'] = profile_data["appliedRadios"] + + default_profile._name = profile_data['profile_name'] + default_profile._details['vlanId'] = profile_data['vlan'] + default_profile._details['ssid'] = profile_data['ssid_name'] + default_profile._details['forwardMode'] = profile_data['mode'] + default_profile._details["radiusServiceId"] = self.profile_creation_ids["radius"][0] + default_profile._child_profile_ids = self.profile_creation_ids["radius"] + default_profile._details['secureMode'] = 'wpa2OnlyRadius' + profile = self.profile_client.create_profile(body=default_profile) + profile_id = profile._id + self.profile_creation_ids['ssid'].append(profile_id) + self.profile_ids.append(profile_id) + except Exception as e: + print(e) + profile = False + return profile + + # wpa2 enterprise mode ssid profile def create_wpa2_enterprise_ssid_profile(self, profile_data=None): try: if profile_data is None: @@ -576,6 +678,7 @@ class ProfileUtility: profile = False return profile + # wpa3 enterprise mode def create_wpa3_enterprise_ssid_profile(self, profile_data=None): try: if profile_data is None: @@ -598,6 +701,29 @@ class ProfileUtility: profile = False return profile + # wpa3 enterprise mixed mode + def create_wpa3_enterprise_mixed_ssid_profile(self, profile_data=None): + try: + if profile_data is None: + return False + default_profile = self.default_profiles['ssid'] + default_profile._details['appliedRadios'] = profile_data["appliedRadios"] + default_profile._name = profile_data['profile_name'] + default_profile._details['vlanId'] = profile_data['vlan'] + default_profile._details['ssid'] = profile_data['ssid_name'] + default_profile._details['forwardMode'] = profile_data['mode'] + default_profile._details["radiusServiceId"] = self.profile_creation_ids["radius"][0] + default_profile._child_profile_ids = self.profile_creation_ids["radius"] + default_profile._details['secureMode'] = 'wpa3MixedEAP' + profile = self.profile_client.create_profile(body=default_profile) + profile_id = profile._id + self.profile_creation_ids['ssid'].append(profile_id) + self.profile_ids.append(profile_id) + except Exception as e: + print(e) + profile = False + return profile + """ method call: used to create a ap profile that contains the given ssid profiles """ @@ -714,8 +840,6 @@ class JFrogUtility: def __init__(self, credentials=None): if credentials is None: exit() - self.user = credentials["username"] - self.password = credentials["password"] self.jfrog_url = credentials["jfrog-base-url"] self.build = credentials["build"] self.branch = credentials["branch"] @@ -723,13 +847,6 @@ class JFrogUtility: def get_build(self, model=None, version=None): jfrog_url = self.jfrog_url + "/" + model + "/" + self.branch + "/" - # auth = str( - # base64.b64encode( - # bytes('%s:%s' % (self.user, self.password), 'utf-8') - # ), - # 'ascii' - # ).strip() - # headers = {'Authorization': 'Basic ' + auth} ''' FIND THE LATEST FILE NAME''' print(jfrog_url) @@ -738,14 +855,17 @@ class JFrogUtility: # print(response) html = response.read() soup = BeautifulSoup(html, features="html.parser") + if self.branch == "trunk": + self.build = model last_link = soup.find_all('a', href=re.compile(self.build)) latest_fw = None for i in last_link: + if str(i['href']).__contains__(version): latest_fw = i['href'] - # latest_file = last_link['href'] latest_fw = latest_fw.replace('.tar.gz', '') + print("Using Firmware Image: ", latest_fw) return latest_fw @@ -780,9 +900,12 @@ class FirmwareUtility(JFrogUtility): def get_fw_version(self): # Get The equipment model self.latest_fw = self.get_build(model=self.model, version=self.fw_version) + print("shivam", self.latest_fw) return self.latest_fw def upload_fw_on_cloud(self, fw_version=None, force_upload=False): + print("Upload fw version :", fw_version) + # force_upload = True # if fw_latest available and force upload is False -- Don't upload # if fw_latest available and force upload is True -- Upload # if fw_latest is not available -- Upload @@ -804,10 +927,9 @@ class FirmwareUtility(JFrogUtility): "modelId": fw_version.split("-")[0], "versionName": fw_version + ".tar.gz", "description": fw_version + " FW VERSION", - "filename": "https://tip.jfrog.io/artifactory/tip-wlan-ap-firmware/" + fw_version.split("-")[ - 0] + "/dev/" + fw_version + ".tar.gz", - "commit": fw_version.split("-")[5] + "filename": self.jfrog_url + "/" + self.model + "/" + self.branch + "/" + fw_version + ".tar.gz", } + print(firmware_data["filename"]) firmware_id = self.firmware_client.create_firmware_version(body=firmware_data) print("Force Upload :", force_upload, " Uploaded the Image") return firmware_id._id @@ -853,20 +975,17 @@ class FirmwareUtility(JFrogUtility): print("firmware not available: ", firmware_version) return firmware_version -# controller = { -# 'url': "https://wlan-portal-svc-nola-ext-03.cicd.lab.wlan.tip.build", # API base url for the controller -# 'username': 'support@example.com', -# 'password': 'support', -# 'version': "1.1.0-SNAPSHOT", -# 'commit_date': "2021-04-27" -# } -# api = Controller(controller_data=controller) -# # profile = ProfileUtility(sdk_client=api) -# # profile.cleanup_profiles() -# # # print(api.get_equipment_by_customer_id()) -# # # -# for i in range(0, 300): -# print(i) -# time.sleep(1) -# print(api.get_equipment_by_customer_id()) -# api.disconnect_Controller() + +if __name__ == '__main__': + controller = { + 'url': "https://wlan-portal-svc-nola-ext-03.cicd.lab.wlan.tip.build", # API base url for the controller + 'username': 'support@example.com', + 'password': 'support', + 'version': "1.1.0-SNAPSHOT", + 'commit_date': "2021-04-27" + } + api = Controller(controller_data=controller) + profile = ProfileUtility(sdk_client=api) + # print(profile.get_profile_by_name(profile_name="basic-ext-03-03-SSID-open-0-VLAN")) + profile.get_default_profiles() + api.disconnect_Controller() diff --git a/tests/conftest.py b/tests/conftest.py index c0e3ae308..fc240fa5b 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -140,6 +140,16 @@ def get_apnos(): yield APNOS +@pytest.fixture(scope="session") +def get_equipment_id(setup_controller, testbed, get_configuration): + equipment_id = 0 + if len(get_configuration['access_point']) == 1: + equipment_id = setup_controller.get_equipment_id( + serial_number=get_configuration['access_point'][0]['serial']) + print(equipment_id) + yield equipment_id + + # APNOS SETUP @pytest.fixture(scope="session") def instantiate_access_point(testbed, get_apnos, get_configuration): @@ -187,6 +197,76 @@ def instantiate_firmware(setup_controller, instantiate_jFrog, get_configuration) yield firmware_client_obj +@pytest.fixture(scope="class") +def get_latest_firmware(instantiate_firmware): + fw_version_list = [] + try: + + for fw_obj in instantiate_firmware: + latest_firmware = fw_obj.get_fw_version() + fw_version_list.append(latest_firmware) + except Exception as e: + print(e) + fw_version_list = [] + + yield fw_version_list + + +@pytest.fixture(scope="class") +def upload_firmware(should_upload_firmware, instantiate_firmware, get_latest_firmware): + firmware_id_list = [] + for i in range(0, len(instantiate_firmware)): + firmware_id = instantiate_firmware[i].upload_fw_on_cloud(fw_version=get_latest_firmware[i], + force_upload=should_upload_firmware) + firmware_id_list.append(firmware_id) + yield firmware_id_list + + +@pytest.fixture(scope="class") +def upgrade_firmware(request, instantiate_firmware, get_equipment_id, check_ap_firmware_cloud, get_latest_firmware, + should_upgrade_firmware): + status_list = [] + if get_latest_firmware != check_ap_firmware_cloud: + if request.config.getoption("--skip-upgrade"): + status = "skip-upgrade" + status_list.append(status) + else: + + for i in range(0, len(instantiate_firmware)): + status = instantiate_firmware[i].upgrade_fw(equipment_id=get_equipment_id, force_upload=False, + force_upgrade=should_upgrade_firmware) + status_list.append(status) + else: + if should_upgrade_firmware: + for i in range(0, len(instantiate_firmware)): + status = instantiate_firmware[i].upgrade_fw(equipment_id=get_equipment_id, force_upload=False, + force_upgrade=should_upgrade_firmware) + status_list.append(status) + else: + status = "skip-upgrade Version Already Available" + status_list.append(status) + yield status_list + + +@pytest.fixture(scope="class") +def check_ap_firmware_cloud(setup_controller, get_equipment_id): + yield setup_controller.get_ap_firmware_old_method(equipment_id=get_equipment_id) + + +@pytest.fixture(scope="class") +def check_ap_firmware_ssh(get_configuration): + active_fw_list = [] + try: + for access_point in get_configuration['access_point']: + ap_ssh = APNOS(access_point) + active_fw = ap_ssh.get_active_firmware() + active_fw_list.append(active_fw) + except Exception as e: + print(e) + active_fw_list = [] + yield active_fw_list + + """ Instantiate Reporting """ diff --git a/tests/e2e/basic/conftest.py b/tests/e2e/basic/conftest.py index 69dc3f025..b51a3bf64 100644 --- a/tests/e2e/basic/conftest.py +++ b/tests/e2e/basic/conftest.py @@ -16,16 +16,6 @@ import pytest import allure -@pytest.fixture(scope="session") -def get_equipment_id(setup_controller, testbed, get_configuration): - equipment_id = 0 - if len(get_configuration['access_point']) == 1: - equipment_id = setup_controller.get_equipment_id( - serial_number=get_configuration['access_point'][0]['serial']) - print(equipment_id) - yield equipment_id - - @pytest.fixture(scope="session") def instantiate_profile(): yield ProfileUtility @@ -41,8 +31,8 @@ def setup_vlan(): @allure.feature("CLIENT CONNECTIVITY SETUP") @pytest.fixture(scope="class") def setup_profiles(request, setup_controller, testbed, setup_vlan, get_equipment_id, - instantiate_profile, get_markers, - get_security_flags, get_configuration, radius_info, get_apnos): + instantiate_profile, get_markers, + get_security_flags, get_configuration, radius_info, get_apnos): instantiate_profile = instantiate_profile(sdk_client=setup_controller) vlan_id, mode = 0, 0 instantiate_profile.cleanup_objects() @@ -375,3 +365,25 @@ def setup_profiles(request, setup_controller, testbed, setup_vlan, get_equipment def lf_test(get_configuration): obj = RunTest(lanforge_data=get_configuration['traffic_generator']['details']) yield obj + + +@pytest.fixture(scope="session") +def station_names_twog(request, get_configuration): + station_names = [] + for i in range(0, int(request.config.getini("num_stations"))): + station_names.append(get_configuration["traffic_generator"]["details"]["2.4G-Station-Name"] + "0" + str(i)) + yield station_names + + +@pytest.fixture(scope="session") +def station_names_fiveg(request, get_configuration): + station_names = [] + for i in range(0, int(request.config.getini("num_stations"))): + station_names.append(get_configuration["traffic_generator"]["details"]["5G-Station-Name"] + "0" + str(i)) + yield station_names + + +@pytest.fixture(scope="session") +def num_stations(request): + num_sta = int(request.config.getini("num_stations")) + yield num_sta diff --git a/tests/e2e/basic/test_firmware.py b/tests/e2e/basic/test_firmware.py index 6074937b7..63c312df8 100644 --- a/tests/e2e/basic/test_firmware.py +++ b/tests/e2e/basic/test_firmware.py @@ -8,68 +8,62 @@ import pytest pytestmark = [pytest.mark.firmware, pytest.mark.sanity] -# @pytest.mark.configure_lanforge -# def test_configure_lanforge(configure_lanforge): -# assert True -# - @pytest.mark.firmware_cloud class TestFirmware(object): @pytest.mark.firmware_create - def test_firmware_create(self, upload_firmware, instantiate_testrail, instantiate_project, test_cases): + def test_firmware_create(self, upload_firmware, update_report, test_cases): if upload_firmware != 0: - instantiate_testrail.update_testrail(case_id=test_cases["create_fw"], run_id=instantiate_project, - status_id=1, - msg='Create new FW version by API successful') + update_report.update_testrail(case_id=test_cases["create_fw"], + status_id=1, + msg='Create new FW version by API successful') PASS = True else: - instantiate_testrail.update_testrail(case_id=test_cases["create_fw"], run_id=instantiate_project, - status_id=5, - msg='Error creating new FW version by API') + update_report.update_testrail(case_id=test_cases["create_fw"], + status_id=5, + msg='Error creating new FW version by API') PASS = False assert PASS @pytest.mark.firmware_upgrade - def test_firmware_upgrade_request(self, upgrade_firmware, instantiate_testrail, instantiate_project, test_cases): + def test_firmware_upgrade_request(self, upgrade_firmware, update_report, test_cases): print() if not upgrade_firmware: - instantiate_testrail.update_testrail(case_id=test_cases["upgrade_api"], run_id=instantiate_project, - status_id=0, - msg='Error requesting upgrade via API') + update_report.update_testrail(case_id=test_cases["upgrade_api"], + status_id=0, + msg='Error requesting upgrade via API') PASS = False else: - instantiate_testrail.update_testrail(case_id=test_cases["upgrade_api"], run_id=instantiate_project, - status_id=1, - msg='Upgrade request using API successful') + update_report.update_testrail(case_id=test_cases["upgrade_api"], + status_id=1, + msg='Upgrade request using API successful') PASS = True assert PASS @pytest.mark.check_active_firmware_cloud - def test_active_version_cloud(self, get_latest_firmware, check_ap_firmware_cloud, instantiate_testrail, - instantiate_project, test_cases): + def test_active_version_cloud(self, get_latest_firmware, check_ap_firmware_cloud, update_report, test_cases): if get_latest_firmware != check_ap_firmware_cloud: - instantiate_testrail.update_testrail(case_id=test_cases["cloud_fw"], run_id=instantiate_project, - status_id=5, - msg='CLOUDSDK reporting incorrect firmware version.') + update_report.update_testrail(case_id=test_cases["cloud_fw"], + status_id=5, + msg='CLOUDSDK reporting incorrect firmware version.') else: - instantiate_testrail.update_testrail(case_id=test_cases["cloud_fw"], run_id=instantiate_project, - status_id=1, - msg='CLOUDSDK reporting correct firmware version.') + update_report.update_testrail(case_id=test_cases["cloud_fw"], + status_id=1, + msg='CLOUDSDK reporting correct firmware version.') assert get_latest_firmware == check_ap_firmware_cloud @pytest.mark.firmware_ap -def test_ap_firmware(check_ap_firmware_ssh, get_latest_firmware, instantiate_testrail, instantiate_project, +def test_ap_firmware(check_ap_firmware_ssh, get_latest_firmware, update_report, test_cases): if check_ap_firmware_ssh == get_latest_firmware: - instantiate_testrail.update_testrail(case_id=test_cases["ap_upgrade"], run_id=instantiate_project, - status_id=1, - msg='Upgrade to ' + get_latest_firmware + ' successful') + update_report.update_testrail(case_id=test_cases["ap_upgrade"], + status_id=1, + msg='Upgrade to ' + get_latest_firmware + ' successful') else: - instantiate_testrail.update_testrail(case_id=test_cases["ap_upgrade"], run_id=instantiate_project, - status_id=4, - msg='Cannot reach AP after upgrade to check CLI - re-test required') + update_report.update_testrail(case_id=test_cases["ap_upgrade"], + status_id=4, + msg='Cannot reach AP after upgrade to check CLI - re-test required') assert check_ap_firmware_ssh == get_latest_firmware diff --git a/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_basic_security.py b/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_security_modes.py similarity index 100% rename from tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_basic_security.py rename to tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_security_modes.py diff --git a/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_basic_security.py b/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_security_modes.py similarity index 100% rename from tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_basic_security.py rename to tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_security_modes.py diff --git a/tests/test_connectivity.py b/tests/test_connectivity.py index fca9337e2..1df99440b 100644 --- a/tests/test_connectivity.py +++ b/tests/test_connectivity.py @@ -32,6 +32,7 @@ class TestResources(object): @allure.testcase(name="test_access_points_connectivity", url="") def test_access_points_connectivity(self, test_access_point, update_report, test_cases): flag = True + print(test_access_point) for i in test_access_point: if "ACTIVE" not in i: flag = False From 8793e15026b7bb2fc2b8916637f1e0a74fcddadd Mon Sep 17 00:00:00 2001 From: shivamcandela Date: Tue, 18 May 2021 08:30:41 +0530 Subject: [PATCH 12/21] Test case fixes Signed-off-by: shivamcandela --- libs/apnos/apnos.py | 2 +- libs/controller/controller.py | 10 +- libs/lanforge/lf_tests.py | 40 +----- tests/conftest.py | 16 +-- tests/e2e/basic/conftest.py | 3 +- tests/e2e/basic/test_firmware.py | 30 ++--- .../test_security_modes.py | 118 +++++++++--------- .../test_security_modes.py | 92 +++++++------- .../test_security_modes.py | 2 +- tests/test_connectivity.py | 2 +- 10 files changed, 145 insertions(+), 170 deletions(-) diff --git a/libs/apnos/apnos.py b/libs/apnos/apnos.py index a09a6d5c1..84b20888f 100644 --- a/libs/apnos/apnos.py +++ b/libs/apnos/apnos.py @@ -161,7 +161,7 @@ class APNOS: stdin, stdout, stderr = client.exec_command(cmd) output = stdout.read() status = str(output.decode('utf-8').splitlines()) - print(output, stderr.read()) + # print(output, stderr.read()) client.close() except Exception as e: print(e) diff --git a/libs/controller/controller.py b/libs/controller/controller.py index 8070d2f62..39d1e73ac 100644 --- a/libs/controller/controller.py +++ b/libs/controller/controller.py @@ -178,7 +178,7 @@ class Controller(ConfigureController): # Get the equipment id, of a equipment with a serial number def get_equipment_id(self, serial_number=None): equipment_data = self.get_equipment_by_customer_id(max_items=100) - print(len(equipment_data)) + # print(len(equipment_data)) for equipment in equipment_data: if equipment._serial == serial_number: return equipment._id @@ -210,7 +210,7 @@ class Controller(ConfigureController): # print(status_data) try: current_ap_fw = status_data[2]['details']['reportedSwVersion'] - print(current_ap_fw) + # print(current_ap_fw) return current_ap_fw except: current_ap_fw = "error" @@ -341,7 +341,7 @@ class ProfileUtility: self.default_profiles['radius'] = i if i._name == "TipWlan-rf": self.default_profiles['rf'] = i - print(i) + # print(i) # This will delete the Profiles associated with an equipment of givwn equipment_id, and associate it to default # equipment_ap profile def delete_current_profile(self, equipment_id=None): @@ -383,7 +383,7 @@ class ProfileUtility: for i in self.default_profiles: skip_delete_id.append(self.default_profiles[i]._id) delete_ids = list(set(delete_ids) - set(delete_ids).intersection(set(skip_delete_id))) - print(delete_ids) + # print(delete_ids) for i in delete_ids: self.set_equipment_to_profile(profile_id=i) self.delete_profile(profile_id=delete_ids) @@ -900,7 +900,7 @@ class FirmwareUtility(JFrogUtility): def get_fw_version(self): # Get The equipment model self.latest_fw = self.get_build(model=self.model, version=self.fw_version) - print("shivam", self.latest_fw) + # print("shivam", self.latest_fw) return self.latest_fw def upload_fw_on_cloud(self, fw_version=None, force_upload=False): diff --git a/libs/lanforge/lf_tests.py b/libs/lanforge/lf_tests.py index 1286c747e..d04f49def 100644 --- a/libs/lanforge/lf_tests.py +++ b/libs/lanforge/lf_tests.py @@ -5,8 +5,8 @@ from sta_connect2 import StaConnect2 import time -from eap_connect import EAPConnect - +# from eap_connect import EAPConnect +from test_ipv4_ttls import TTLSTest class RunTest: @@ -67,35 +67,7 @@ class RunTest: time.sleep(3) return self.staConnect.passes(), result - def Single_Client_EAP(self, port, sta_list, ssid_name, radio, security, eap_type, - identity, ttls_password, test_case, rid, client, logger): - eap_connect = EAPConnect(self.lanforge_ip, self.lanforge_port, _debug_on=False) - eap_connect.upstream_resource = 1 - eap_connect.upstream_port = port - eap_connect.security = security - eap_connect.sta_list = sta_list - eap_connect.station_names = sta_list - eap_connect.sta_prefix = self.lanforge_prefix - eap_connect.ssid = ssid_name - eap_connect.radio = radio - eap_connect.eap = eap_type - eap_connect.identity = identity - eap_connect.ttls_passwd = ttls_password - eap_connect.runtime_secs = 40 - eap_connect.setup() - eap_connect.start() - print("napping %f sec" % eap_connect.runtime_secs) - time.sleep(eap_connect.runtime_secs) - eap_connect.stop() - eap_connect.cleanup() - run_results = eap_connect.get_result_list() - for result in run_results: - print("test result: " + result) - result = True - print("Single Client Connectivity :", eap_connect.passes) - if eap_connect.passes(): - print("Single client connection to", ssid_name, "successful. Test Passed") - else: - print("Single client connection to", ssid_name, "unsuccessful. Test Failed") - result = False - return self.staConnect.passes(), result + # def Client_Connectivity_EAP(self, ssid="[BLANK]", passwd="[BLANK]", key_mgmt= "WPA-EAP", + # pairwise="", group="", wpa_psk="", identity="", station_name=[], + # mode="BRIDGE", security="wpa2", eap_type, + # identity, ttls_password, test_case, rid, client, logger): diff --git a/tests/conftest.py b/tests/conftest.py index fc240fa5b..6a89ca614 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -142,12 +142,11 @@ def get_apnos(): @pytest.fixture(scope="session") def get_equipment_id(setup_controller, testbed, get_configuration): - equipment_id = 0 - if len(get_configuration['access_point']) == 1: - equipment_id = setup_controller.get_equipment_id( - serial_number=get_configuration['access_point'][0]['serial']) - print(equipment_id) - yield equipment_id + equipment_id_list = [] + for i in get_configuration['access_point']: + equipment_id_list.append(setup_controller.get_equipment_id( + serial_number=i['serial'])) + yield equipment_id_list # APNOS SETUP @@ -250,7 +249,10 @@ def upgrade_firmware(request, instantiate_firmware, get_equipment_id, check_ap_f @pytest.fixture(scope="class") def check_ap_firmware_cloud(setup_controller, get_equipment_id): - yield setup_controller.get_ap_firmware_old_method(equipment_id=get_equipment_id) + ap_fw_list = [] + for i in get_equipment_id: + ap_fw_list.append(setup_controller.get_ap_firmware_old_method(equipment_id=i)) + yield ap_fw_list @pytest.fixture(scope="class") diff --git a/tests/e2e/basic/conftest.py b/tests/e2e/basic/conftest.py index b51a3bf64..e9695fb4e 100644 --- a/tests/e2e/basic/conftest.py +++ b/tests/e2e/basic/conftest.py @@ -303,7 +303,8 @@ def setup_profiles(request, setup_controller, testbed, setup_vlan, get_equipment # Push the Equipment AP Profile to AP try: - instantiate_profile.push_profile_old_method(equipment_id=get_equipment_id) + for i in get_equipment_id: + instantiate_profile.push_profile_old_method(equipment_id=i) except Exception as e: print(e) print("failed to create AP Profile") diff --git a/tests/e2e/basic/test_firmware.py b/tests/e2e/basic/test_firmware.py index 63c312df8..559e9e478 100644 --- a/tests/e2e/basic/test_firmware.py +++ b/tests/e2e/basic/test_firmware.py @@ -25,20 +25,20 @@ class TestFirmware(object): PASS = False assert PASS - @pytest.mark.firmware_upgrade - def test_firmware_upgrade_request(self, upgrade_firmware, update_report, test_cases): - print() - if not upgrade_firmware: - update_report.update_testrail(case_id=test_cases["upgrade_api"], - status_id=0, - msg='Error requesting upgrade via API') - PASS = False - else: - update_report.update_testrail(case_id=test_cases["upgrade_api"], - status_id=1, - msg='Upgrade request using API successful') - PASS = True - assert PASS + # @pytest.mark.firmware_upgrade + # def test_firmware_upgrade_request(self, upgrade_firmware, update_report, test_cases): + # print() + # if not upgrade_firmware: + # update_report.update_testrail(case_id=test_cases["upgrade_api"], + # status_id=0, + # msg='Error requesting upgrade via API') + # PASS = False + # else: + # update_report.update_testrail(case_id=test_cases["upgrade_api"], + # status_id=1, + # msg='Upgrade request using API successful') + # PASS = True + # assert PASS @pytest.mark.check_active_firmware_cloud def test_active_version_cloud(self, get_latest_firmware, check_ap_firmware_cloud, update_report, test_cases): @@ -60,7 +60,7 @@ def test_ap_firmware(check_ap_firmware_ssh, get_latest_firmware, update_report, if check_ap_firmware_ssh == get_latest_firmware: update_report.update_testrail(case_id=test_cases["ap_upgrade"], status_id=1, - msg='Upgrade to ' + get_latest_firmware + ' successful') + msg='Upgrade to ' + str(get_latest_firmware) + ' successful') else: update_report.update_testrail(case_id=test_cases["ap_upgrade"], status_id=4, diff --git a/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py b/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py index 449f00e38..f022076d1 100644 --- a/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py +++ b/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py @@ -130,14 +130,14 @@ class TestBridgeModeConnectivity(object): station_name=station_names_fiveg, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["5g_wpa_bridge"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + msg='5G WPA Client Connectivity Passed successfully - bridge mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["5g_wpa_bridge"], status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( + msg='5G WPA Client Connectivity Failed - bridge mode' + str( passes)) assert result @@ -158,14 +158,14 @@ class TestBridgeModeConnectivity(object): station_name=station_names_twog, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa2_bridge"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + msg='2G WPA2 Client Connectivity Passed successfully - bridge mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa2_bridge"], status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( + msg='2G WPA2 Client Connectivity Failed - bridge mode' + str( passes)) assert result @@ -186,63 +186,63 @@ class TestBridgeModeConnectivity(object): station_name=station_names_fiveg, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["5g_wpa2_bridge"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + msg='5G WPA2 Client Connectivity Passed successfully - bridge mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["5g_wpa2_bridge"], status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( + msg='5G WPA2 Client Connectivity Failed - bridge mode' + str( passes)) assert result -setup_params_enterprise = { - "mode": "BRIDGE", - "ssid_modes": { - "wpa2_enterprise": [ - {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}], - "wpa3_enterprise": [ - {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, - {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, - - "rf": {}, - "radius": True -} - - -@pytest.mark.enterprise -@pytest.mark.parametrize( - 'setup_profiles', - [setup_params_enterprise], - indirect=True, - scope="package" -) -@pytest.mark.usefixtures("setup_profiles") -class TestBridgeModeEnterprise(object): - - @pytest.mark.wpa2_enterprise - @pytest.mark.twog - def test_wpa2_enterprise_2g(self): - # print(setup_client_connectivity) - assert "setup_client_connectivity" - - @pytest.mark.wpa2_enterprise - @pytest.mark.fiveg - def test_wpa2_enterprise_5g(self): - assert "setup_client_connectivity" - - @pytest.mark.wpa3_enterprise - @pytest.mark.twog - def test_wpa3_enterprise_2g(self): - # print(setup_client_connectivity) - assert "setup_client_connectivity" - - @pytest.mark.wpa3_enterprise - @pytest.mark.fiveg - def test_wpa3_enterprise_5g(self): - assert "setup_client_connectivity" +# setup_params_enterprise = { +# "mode": "BRIDGE", +# "ssid_modes": { +# "wpa2_enterprise": [ +# {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, +# {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], +# "security_key": "something"}], +# "wpa3_enterprise": [ +# {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, +# {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, +# +# "rf": {}, +# "radius": True +# } +# +# +# @pytest.mark.enterprise +# @pytest.mark.parametrize( +# 'setup_profiles', +# [setup_params_enterprise], +# indirect=True, +# scope="package" +# ) +# @pytest.mark.usefixtures("setup_profiles") +# class TestBridgeModeEnterprise(object): +# +# @pytest.mark.wpa2_enterprise +# @pytest.mark.twog +# def test_wpa2_enterprise_2g(self): +# # print(setup_client_connectivity) +# assert "setup_client_connectivity" +# +# @pytest.mark.wpa2_enterprise +# @pytest.mark.fiveg +# def test_wpa2_enterprise_5g(self): +# assert "setup_client_connectivity" +# +# @pytest.mark.wpa3_enterprise +# @pytest.mark.twog +# def test_wpa3_enterprise_2g(self): +# # print(setup_client_connectivity) +# assert "setup_client_connectivity" +# +# @pytest.mark.wpa3_enterprise +# @pytest.mark.fiveg +# def test_wpa3_enterprise_5g(self): +# assert "setup_client_connectivity" diff --git a/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_security_modes.py b/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_security_modes.py index 0d33b2891..87bd4bf25 100644 --- a/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_security_modes.py +++ b/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_security_modes.py @@ -212,49 +212,49 @@ class TestNATModeConnectivity(object): assert result -setup_params_enterprise = { - "mode": "NAT", - "ssid_modes": { - "wpa2_enterprise": [ - {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}], - "wpa3_enterprise": [ - {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, - {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, - - "rf": {}, - "radius": True -} - - -@pytest.mark.parametrize( - 'setup_profiles', - [setup_params_enterprise], - indirect=True, - scope="package" -) -@pytest.mark.usefixtures("setup_profiles") -class TestNATModeEnterprise(object): - - @pytest.mark.wpa2_enterprise - @pytest.mark.twog - def test_wpa2_enterprise_2g(self): - # print(setup_client_connectivity) - assert "setup_client_connectivity" - - @pytest.mark.wpa2_enterprise - @pytest.mark.fiveg - def test_wpa2_enterprise_5g(self): - assert "setup_client_connectivity" - - @pytest.mark.wpa3_enterprise - @pytest.mark.twog - def test_wpa3_enterprise_2g(self): - # print(setup_client_connectivity) - assert "setup_client_connectivity" - - @pytest.mark.wpa3_enterprise - @pytest.mark.fiveg - def test_wpa3_enterprise_5g(self): - assert "setup_client_connectivity" +# setup_params_enterprise = { +# "mode": "NAT", +# "ssid_modes": { +# "wpa2_enterprise": [ +# {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, +# {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], +# "security_key": "something"}], +# "wpa3_enterprise": [ +# {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, +# {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, +# +# "rf": {}, +# "radius": True +# } +# +# +# @pytest.mark.parametrize( +# 'setup_profiles', +# [setup_params_enterprise], +# indirect=True, +# scope="package" +# ) +# @pytest.mark.usefixtures("setup_profiles") +# class TestNATModeEnterprise(object): +# +# @pytest.mark.wpa2_enterprise +# @pytest.mark.twog +# def test_wpa2_enterprise_2g(self): +# # print(setup_client_connectivity) +# assert "setup_client_connectivity" +# +# @pytest.mark.wpa2_enterprise +# @pytest.mark.fiveg +# def test_wpa2_enterprise_5g(self): +# assert "setup_client_connectivity" +# +# @pytest.mark.wpa3_enterprise +# @pytest.mark.twog +# def test_wpa3_enterprise_2g(self): +# # print(setup_client_connectivity) +# assert "setup_client_connectivity" +# +# @pytest.mark.wpa3_enterprise +# @pytest.mark.fiveg +# def test_wpa3_enterprise_5g(self): +# assert "setup_client_connectivity" diff --git a/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_security_modes.py b/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_security_modes.py index 753dbf6d7..359e01f77 100644 --- a/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_security_modes.py +++ b/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_security_modes.py @@ -33,7 +33,7 @@ class TestVLANModeConnectivity(object): @pytest.mark.open @pytest.mark.twog @allure.story('open 2.4 GHZ Band') - def test_open_ssid_2g(self, request, get_lanforge_data, lf_test, update_report, test_cases): + def test_open_ssid_2g(self, setup_profiles, request, get_lanforge_data, lf_test, update_report, test_cases): profile_data = setup_params_general["ssid_modes"]["open"][0] ssid_name = profile_data["ssid_name"] security_key = "[BLANK]" diff --git a/tests/test_connectivity.py b/tests/test_connectivity.py index 1df99440b..f472eb814 100644 --- a/tests/test_connectivity.py +++ b/tests/test_connectivity.py @@ -25,7 +25,7 @@ class TestResources(object): update_report.update_testrail(case_id=test_cases["cloud_ver"], status_id=0, msg='Could not read CloudSDK version from API') pytest.exit("Resource Not Available") - print(setup_controller.bearer) + # print(setup_controller.bearer) assert setup_controller.bearer @pytest.mark.test_access_points_connectivity From 90fd980baf0f52e299e0e3a1d7cf0e73945926c0 Mon Sep 17 00:00:00 2001 From: shivamcandela Date: Wed, 19 May 2021 11:28:10 +0530 Subject: [PATCH 13/21] wpa3 personal and mixed mode ssid modes Signed-off-by: shivamcandela --- tests/conftest.py | 3 +- tests/e2e/basic/conftest.py | 32 +++- .../test_security_modes.py | 147 ++++++++++++++++++ .../test_security_modes.py | 30 ++-- 4 files changed, 195 insertions(+), 17 deletions(-) diff --git a/tests/conftest.py b/tests/conftest.py index 6a89ca614..a8ba995df 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -304,7 +304,8 @@ FRAMEWORK MARKER LOGIC @pytest.fixture(scope="session") def get_security_flags(): # Add more classifications as we go - security = ["open", "wpa", "wpa2_personal", "wpa2_enterprise", "wpa3_enterprise", "twog", "fiveg", "radius"] + security = ["open", "wpa", "wpa2_personal", "wpa3_personal", "wpa3_personal_mixed", + "wpa2_enterprise", "wpa3_enterprise", "twog", "fiveg", "radius"] yield security diff --git a/tests/e2e/basic/conftest.py b/tests/e2e/basic/conftest.py index e9695fb4e..4ae800bdb 100644 --- a/tests/e2e/basic/conftest.py +++ b/tests/e2e/basic/conftest.py @@ -37,6 +37,7 @@ def setup_profiles(request, setup_controller, testbed, setup_vlan, get_equipment vlan_id, mode = 0, 0 instantiate_profile.cleanup_objects() parameter = dict(request.param) + print(parameter) test_cases = {} profile_data = {} if parameter['mode'] not in ["BRIDGE", "NAT", "VLAN"]: @@ -204,7 +205,7 @@ def setup_profiles(request, setup_controller, testbed, setup_vlan, get_equipment if mode == "wpa3_personal": for j in profile_data["ssid"][mode]: - # print(j) + print(j) if mode in get_markers.keys() and get_markers[mode]: try: if "twog" in get_markers.keys() and get_markers["twog"] and "is2dot4GHz" in list( @@ -230,6 +231,35 @@ def setup_profiles(request, setup_controller, testbed, setup_vlan, get_equipment test_cases["wpa3_personal_5g"] = False allure.attach(body=str(e), name="SSID Profile Creation Failed") + if mode == "wpa3_personal_mixed": + for j in profile_data["ssid"][mode]: + print(j) + if mode in get_markers.keys() and get_markers[mode]: + try: + if "twog" in get_markers.keys() and get_markers["twog"] and "is2dot4GHz" in list( + j["appliedRadios"]): + creates_profile = instantiate_profile.create_wpa3_personal_mixed_ssid_profile(profile_data=j) + test_cases["wpa3_personal_mixed_2g"] = True + allure.attach(body=str(creates_profile), + name="SSID Profile Created") + except Exception as e: + print(e) + test_cases["wpa3_personal_2g"] = False + allure.attach(body=str(e), + name="SSID Profile Creation Failed") + try: + if "fiveg" in get_markers.keys() and get_markers["fiveg"] and "is5GHz" in list( + j["appliedRadios"]): + creates_profile = instantiate_profile.create_wpa3_personal_mixed_ssid_profile(profile_data=j) + test_cases["wpa3_personal_mixed_5g"] = True + allure.attach(body=str(creates_profile), + name="SSID Profile Created") + except Exception as e: + print(e) + test_cases["wpa3_personal_5g"] = False + allure.attach(body=str(e), + name="SSID Profile Creation Failed") + if mode == "wpa2_enterprise": for j in profile_data["ssid"][mode]: diff --git a/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_security_modes.py b/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_security_modes.py index 87bd4bf25..aa9ec3a74 100644 --- a/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_security_modes.py +++ b/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_security_modes.py @@ -212,6 +212,153 @@ class TestNATModeConnectivity(object): assert result +setup_params_general_two = { + "mode": "NAT", + "ssid_modes": { + "wpa3_personal": [ + {"ssid_name": "ssid_wpa3_p_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa3_p_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa3_personal_mixed": [ + {"ssid_name": "ssid_wpa3_p_m_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa3_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}] + }, + "rf": {}, + "radius": False +} + +@pytest.mark.shivam +@allure.feature("NAT MODE CLIENT CONNECTIVITY") +@pytest.mark.parametrize( + 'setup_profiles', + [setup_params_general_two], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_profiles") +class TestNATModeConnectivity(object): + + @pytest.mark.wpa3_personal + @pytest.mark.twog + @allure.story('open 2.4 GHZ Band') + def test_wpa3_personal_ssid_2g(self, request, setup_profiles, get_lanforge_data, lf_test, update_report, test_cases): + profile_data = setup_params_general_two["ssid_modes"]["wpa3_personal"][0] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa3" + station_names = [] + for i in range(0, int(request.config.getini("num_stations"))): + station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) + mode = "NAT" + band = "twog" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + @pytest.mark.wpa3_personal + @pytest.mark.fiveg + @allure.story('open 5 GHZ Band') + def test_wpa3_personal_ssid_5g(self, request, get_lanforge_data, lf_test, test_cases, update_report): + profile_data = setup_params_general_two["ssid_modes"]["wpa3_personal"][1] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa3" + station_names = [] + for i in range(0, int(request.config.getini("num_stations"))): + station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) + mode = "NAT" + band = "fiveg" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + @pytest.mark.wpa3_personal_mixed + @pytest.mark.twog + @allure.story('open 2.4 GHZ Band') + def test_wpa3_personal_mixed_ssid_2g(self, request, setup_profiles, get_lanforge_data, lf_test, update_report, test_cases): + profile_data = setup_params_general_two["ssid_modes"]["wpa3_personal_mixed"][0] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa3" + station_names = [] + for i in range(0, int(request.config.getini("num_stations"))): + station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) + mode = "NAT" + band = "twog" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + @pytest.mark.wpa3_personal_mixed + @pytest.mark.fiveg + @allure.story('open 5 GHZ Band') + def test_wpa3_personal_mixed_ssid_5g(self, request, get_lanforge_data, lf_test, test_cases, update_report): + profile_data = setup_params_general_two["ssid_modes"]["wpa3_personal_mixed"][1] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa3" + station_names = [] + for i in range(0, int(request.config.getini("num_stations"))): + station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) + mode = "NAT" + band = "fiveg" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + # setup_params_enterprise = { # "mode": "NAT", # "ssid_modes": { diff --git a/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_security_modes.py b/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_security_modes.py index 359e01f77..cf3b61bf9 100644 --- a/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_security_modes.py +++ b/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_security_modes.py @@ -212,21 +212,21 @@ class TestVLANModeConnectivity(object): assert result -# setup_params_enterprise = { -# "mode": "BRIDGE", -# "ssid_modes": { -# "wpa2_enterprise": [ -# {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, -# {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], -# "security_key": "something"}], -# "wpa3_enterprise": [ -# {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, -# {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, -# -# "rf": {}, -# "radius": True -# } -# +setup_params_enterprise = { + "mode": "VLAN", + "ssid_modes": { + "wpa2_enterprise": [ + {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa3_enterprise": [ + {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, + + "rf": {}, + "radius": True +} + # # @pytest.mark.parametrize( # 'setup_profiles', From 60248a9a0e841c5181a388f1d83204ddea4380b1 Mon Sep 17 00:00:00 2001 From: shivamcandela Date: Wed, 19 May 2021 19:21:54 +0530 Subject: [PATCH 14/21] nat and vlan modes in security Signed-off-by: shivamcandela --- libs/controller/controller.py | 6 +- .../test_security_modes.py | 141 ++++++++++++++++- .../test_security_modes.py | 15 +- .../test_security_modes.py | 146 ++++++++++++++++++ 4 files changed, 298 insertions(+), 10 deletions(-) diff --git a/libs/controller/controller.py b/libs/controller/controller.py index 39d1e73ac..f3e0b8c6b 100644 --- a/libs/controller/controller.py +++ b/libs/controller/controller.py @@ -342,6 +342,7 @@ class ProfileUtility: if i._name == "TipWlan-rf": self.default_profiles['rf'] = i # print(i) + # This will delete the Profiles associated with an equipment of givwn equipment_id, and associate it to default # equipment_ap profile def delete_current_profile(self, equipment_id=None): @@ -417,8 +418,9 @@ class ProfileUtility: "model_type": "PaginationContext", "maxItemsPerPage": 5000 }""" - equipment_data = self.sdk_client.equipment_client.get_equipment_by_customer_id(customer_id=2, - pagination_context=pagination_context) + equipment_data = self.sdk_client.equipment_client. \ + get_equipment_by_customer_id(customer_id=2, + pagination_context=pagination_context) self.get_default_profiles() for i in equipment_data._items: if i._profile_id == profile_id: diff --git a/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py b/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py index f022076d1..6d933db8c 100644 --- a/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py +++ b/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py @@ -29,7 +29,7 @@ setup_params_general = { scope="class" ) @pytest.mark.usefixtures("setup_profiles") -class TestBridgeModeConnectivity(object): +class TestBridgeModeConnectivitySuiteOne(object): @pytest.mark.open @pytest.mark.twog @@ -198,6 +198,144 @@ class TestBridgeModeConnectivity(object): assert result +setup_params_general_two = { + "mode": "BRIDGE", + "ssid_modes": { + "wpa3_personal": [ + {"ssid_name": "ssid_wpa3_p_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa3_p_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa3_personal_mixed": [ + {"ssid_name": "ssid_wpa3_p_m_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa3_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}] + }, + "rf": {}, + "radius": False +} + + +@pytest.mark.shivam +@allure.feature("BRIDGE MODE CLIENT CONNECTIVITY") +@pytest.mark.parametrize( + 'setup_profiles', + [setup_params_general_two], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_profiles") +class TestBridgeModeConnectivitySuiteTwo(object): + + @pytest.mark.wpa3_personal + @pytest.mark.twog + @allure.story('open 2.4 GHZ Band') + def test_wpa3_personal_ssid_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, update_report, + test_cases): + profile_data = setup_params_general_two["ssid_modes"]["wpa3_personal"][0] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = ["wpa3"] + mode = "BRIDGE" + band = "twog" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names_twog, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + @pytest.mark.wpa3_personal + @pytest.mark.fiveg + @allure.story('open 5 GHZ Band') + def test_wpa3_personal_ssid_5g(self, station_names_fiveg, get_lanforge_data, lf_test, test_cases, update_report): + profile_data = setup_params_general_two["ssid_modes"]["wpa3_personal"][1] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = ["wpa3"] + mode = "BRIDGE" + band = "fiveg" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names_fiveg, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + @pytest.mark.wpa3_personal_mixed + @pytest.mark.twog + @allure.story('open 2.4 GHZ Band') + def test_wpa3_personal_mixed_ssid_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, update_report, + test_cases): + profile_data = setup_params_general_two["ssid_modes"]["wpa3_personal_mixed"][0] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa3" + mode = "BRIDGE" + band = "twog" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names_twog, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + @pytest.mark.wpa3_personal_mixed + @pytest.mark.fiveg + @allure.story('open 5 GHZ Band') + def test_wpa3_personal_mixed_ssid_5g(self, station_names_fiveg, get_lanforge_data, lf_test, test_cases, update_report): + profile_data = setup_params_general_two["ssid_modes"]["wpa3_personal_mixed"][1] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa3" + mode = "BRIDGE" + band = "fiveg" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names_fiveg, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + # setup_params_enterprise = { # "mode": "BRIDGE", # "ssid_modes": { @@ -245,4 +383,3 @@ class TestBridgeModeConnectivity(object): # @pytest.mark.fiveg # def test_wpa3_enterprise_5g(self): # assert "setup_client_connectivity" - diff --git a/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_security_modes.py b/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_security_modes.py index aa9ec3a74..2fe3ae775 100644 --- a/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_security_modes.py +++ b/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_security_modes.py @@ -28,7 +28,7 @@ setup_params_general = { scope="class" ) @pytest.mark.usefixtures("setup_profiles") -class TestNATModeConnectivity(object): +class TestNATModeConnectivitySuiteOne(object): @pytest.mark.open @pytest.mark.twog @@ -228,6 +228,7 @@ setup_params_general_two = { "radius": False } + @pytest.mark.shivam @allure.feature("NAT MODE CLIENT CONNECTIVITY") @pytest.mark.parametrize( @@ -237,16 +238,17 @@ setup_params_general_two = { scope="class" ) @pytest.mark.usefixtures("setup_profiles") -class TestNATModeConnectivity(object): +class TestNATModeConnectivitySuiteTwo(object): @pytest.mark.wpa3_personal @pytest.mark.twog @allure.story('open 2.4 GHZ Band') - def test_wpa3_personal_ssid_2g(self, request, setup_profiles, get_lanforge_data, lf_test, update_report, test_cases): + def test_wpa3_personal_ssid_2g(self, request, setup_profiles, get_lanforge_data, lf_test, update_report, + test_cases): profile_data = setup_params_general_two["ssid_modes"]["wpa3_personal"][0] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] - security = "wpa3" + security = ["wpa3"] station_names = [] for i in range(0, int(request.config.getini("num_stations"))): station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) @@ -276,7 +278,7 @@ class TestNATModeConnectivity(object): profile_data = setup_params_general_two["ssid_modes"]["wpa3_personal"][1] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] - security = "wpa3" + security = ["wpa3"] station_names = [] for i in range(0, int(request.config.getini("num_stations"))): station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) @@ -302,7 +304,8 @@ class TestNATModeConnectivity(object): @pytest.mark.wpa3_personal_mixed @pytest.mark.twog @allure.story('open 2.4 GHZ Band') - def test_wpa3_personal_mixed_ssid_2g(self, request, setup_profiles, get_lanforge_data, lf_test, update_report, test_cases): + def test_wpa3_personal_mixed_ssid_2g(self, request, setup_profiles, get_lanforge_data, lf_test, update_report, + test_cases): profile_data = setup_params_general_two["ssid_modes"]["wpa3_personal_mixed"][0] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] diff --git a/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_security_modes.py b/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_security_modes.py index cf3b61bf9..32b67b75d 100644 --- a/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_security_modes.py +++ b/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_security_modes.py @@ -212,6 +212,152 @@ class TestVLANModeConnectivity(object): assert result +setup_params_general_two = { + "mode": "VLAN", + "ssid_modes": { + "wpa3_personal": [ + {"ssid_name": "ssid_wpa3_p_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa3_p_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa3_personal_mixed": [ + {"ssid_name": "ssid_wpa3_p_m_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa3_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}] + }, + "rf": {}, + "radius": False +} + + +@pytest.mark.shivam +@allure.feature("VLAN MODE CLIENT CONNECTIVITY") +@pytest.mark.parametrize( + 'setup_profiles', + [setup_params_general_two], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_profiles") +class TestBridgeModeConnectivitySuiteTwo(object): + + @pytest.mark.wpa3_personal + @pytest.mark.twog + @allure.story('open 2.4 GHZ Band') + def test_wpa3_personal_ssid_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, update_report, + test_cases): + profile_data = setup_params_general_two["ssid_modes"]["wpa3_personal"][0] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = ["wpa3"] + mode = "VLAN" + band = "twog" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names_twog, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + @pytest.mark.wpa3_personal + @pytest.mark.fiveg + @allure.story('open 5 GHZ Band') + def test_wpa3_personal_ssid_5g(self, request, get_lanforge_data, lf_test, test_cases, update_report): + profile_data = setup_params_general_two["ssid_modes"]["wpa3_personal"][1] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = ["wpa3"] + station_names = [] + for i in range(0, int(request.config.getini("num_stations"))): + station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) + mode = "VLAN" + band = "fiveg" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + @pytest.mark.wpa3_personal_mixed + @pytest.mark.twog + @allure.story('open 2.4 GHZ Band') + def test_wpa3_personal_mixed_ssid_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, update_report, + test_cases): + profile_data = setup_params_general_two["ssid_modes"]["wpa3_personal_mixed"][0] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa3" + mode = "VLAN" + band = "twog" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names_twog, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + @pytest.mark.wpa3_personal_mixed + @pytest.mark.fiveg + @allure.story('open 5 GHZ Band') + def test_wpa3_personal_mixed_ssid_5g(self, request, get_lanforge_data, lf_test, test_cases, update_report): + profile_data = setup_params_general_two["ssid_modes"]["wpa3_personal_mixed"][1] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa3" + station_names = [] + for i in range(0, int(request.config.getini("num_stations"))): + station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) + mode = "VLAN" + band = "fiveg" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + + setup_params_enterprise = { "mode": "VLAN", "ssid_modes": { From 9285a1583ce46651c1a35e1580e34f7d1edac7cb Mon Sep 17 00:00:00 2001 From: shivamcandela Date: Thu, 20 May 2021 17:46:39 +0530 Subject: [PATCH 15/21] eap ttls and tls support Signed-off-by: shivamcandela --- libs/lanforge/lf_tests.py | 87 ++++++++++++++++++++++++++++++++++++--- 1 file changed, 82 insertions(+), 5 deletions(-) diff --git a/libs/lanforge/lf_tests.py b/libs/lanforge/lf_tests.py index d04f49def..af67837fd 100644 --- a/libs/lanforge/lf_tests.py +++ b/libs/lanforge/lf_tests.py @@ -2,12 +2,30 @@ # Used by Nightly_Sanity # This has different types of old_pytest like Single client connectivity, Single_Client_EAP, testrail_retest ######################################################################################################### +import sys +import os +sys.path.append( + os.path.dirname( + os.path.realpath(__file__) + ) +) +if "libs" not in sys.path: + sys.path.append(f'../libs') +for folder in 'py-json', 'py-scripts': + if folder not in sys.path: + sys.path.append(f'../../lanforge/lanforge-scripts/{folder}') + +sys.path.append(f"../lanforge/lanforge-scripts/py-scripts/tip-cicd-sanity") + +sys.path.append(f'../libs') +sys.path.append(f'../libs/lanforge/') from sta_connect2 import StaConnect2 import time # from eap_connect import EAPConnect from test_ipv4_ttls import TTLSTest + class RunTest: def __init__(self, lanforge_data=None, debug=False): @@ -20,10 +38,11 @@ class RunTest: self.twog_prefix = lanforge_data["2.4G-Station-Name"] self.fiveg_prefix = lanforge_data["5G-Station-Name"] self.ax_prefix = lanforge_data["AX-Station-Name"] + self.debug = debug self.staConnect = StaConnect2(self.lanforge_ip, self.lanforge_port, debug_=debug) def Client_Connectivity(self, ssid="[BLANK]", passkey="[BLANK]", security="open", station_name=[], - mode="BRIDGE", vlan_id=1, band="twog"): + mode="BRIDGE", vlan_id=1, band="twog"): '''SINGLE CLIENT CONNECTIVITY using test_connect2.py''' self.staConnect.sta_mode = 0 self.staConnect.upstream_resource = 1 @@ -67,7 +86,65 @@ class RunTest: time.sleep(3) return self.staConnect.passes(), result - # def Client_Connectivity_EAP(self, ssid="[BLANK]", passwd="[BLANK]", key_mgmt= "WPA-EAP", - # pairwise="", group="", wpa_psk="", identity="", station_name=[], - # mode="BRIDGE", security="wpa2", eap_type, - # identity, ttls_password, test_case, rid, client, logger): + def EAP_Connect(self, ssid="[BLANK]", passkey="[BLANK]", security="wpa2", mode="BRIDGE", band="twog", vlan_id=100, + station_name=[], key_mgmt="WPA-EAP", + pairwise="NA", group="NA", wpa_psk="DEFAULT", + ttls_passwd="nolastart", + wep_key="NA", ca_cert="NA", eap="TTLS", identity="nolaradius"): + self.eap_connect = TTLSTest(host=self.lanforge_ip, port=self.lanforge_port, + sta_list=station_name, vap=False, _debug_on=self.debug) + + self.eap_connect.station_profile.sta_mode = 0 + self.eap_connect.upstream_resource = 1 + if mode == "BRIDGE": + self.eap_connect.upstream_port = self.upstream_port + elif mode == "NAT": + self.eap_connect.upstream_port = self.upstream_port + else: + self.eap_connect.upstream_port = self.upstream_port + "." + str(vlan_id) + if band == "twog": + self.eap_connect.radio = self.twog_radios[0] + # self.eap_connect.sta_prefix = self.twog_prefix + if band == "fiveg": + self.eap_connect.radio = self.fiveg_radios[0] + # self.eap_connect.sta_prefix = self.fiveg_prefix + # self.eap_connect.resource = 1 + if eap == "TTLS": + self.eap_connect.ieee80211w = 0 + self.eap_connect.station_profile.set_command_flag("add_sta", "80211u_enable", 0) + self.eap_connect.identity = identity + self.eap_connect.ttls_passwd = ttls_passwd + if eap == "TLS": + self.eap_connect.key_mgmt = "WPA-EAP-SUITE-B" + self.eap_connect.station_profile.set_command_flag("add_sta", "80211u_enable", 0) + self.eap_connect.pairwise = "TKIP" + self.eap_connect.group = "TKIP" + self.eap_connect.eap = "EAP-TLS" + + # self.eap_connect.hs20_enable = False + self.eap_connect.ssid = ssid + self.eap_connect.password = passkey + self.eap_connect.security = security + self.eap_connect.sta_list = station_name + self.eap_connect.build() + self.eap_connect.start(station_name, True, True) + self.eap_connect.stop() + self.eap_connect.cleanup(station_name) + return self.eap_connect.passes() + + +if __name__ == '__main__': + lanforge_data = { + "ip": "192.168.200.81", + "port": 8080, + "2.4G-Radio": ["wiphy0"], + "5G-Radio": ["wiphy1"], + "AX-Radio": ["wiphy2"], + "upstream": "eth1", + "2.4G-Station-Name": "wlan0", + "5G-Station-Name": "wlan0", + "AX-Station-Name": "ax", + } + obj = RunTest(lanforge_data=lanforge_data, debug=False) + # print(obj.eap_connect.json_get("port/1/1/sta0000?fields=ap,ip")) + obj.EAP_Connect(station_name=["sta0000", "sta0001"], eap="TTLS", ssid="testing_radius") From c6f061d991a24053124d33a4cab3d87fa0efa7e6 Mon Sep 17 00:00:00 2001 From: shivamcandela Date: Thu, 20 May 2021 18:36:08 +0530 Subject: [PATCH 16/21] test cases for wpa eap and other mixed mode ssids Signed-off-by: shivamcandela --- libs/controller/controller.py | 2 +- .../test_security_modes.py | 329 ++++++++++++--- .../test_security_modes.py | 393 ++++++++++++++---- .../test_security_modes.py | 369 ++++++++++++---- 4 files changed, 889 insertions(+), 204 deletions(-) diff --git a/libs/controller/controller.py b/libs/controller/controller.py index f3e0b8c6b..d22281447 100644 --- a/libs/controller/controller.py +++ b/libs/controller/controller.py @@ -585,7 +585,7 @@ class ProfileUtility: profile = False return profile - # wpa wpa3 personal mixed mode + # wpa wpa2 personal mixed mode def create_wpa_wpa2_personal_mixed_ssid_profile(self, profile_data=None): try: if profile_data is None: diff --git a/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py b/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py index 6d933db8c..74a7db1cd 100644 --- a/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py +++ b/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py @@ -208,6 +208,10 @@ setup_params_general_two = { "wpa3_personal_mixed": [ {"ssid_name": "ssid_wpa3_p_m_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, {"ssid_name": "ssid_wpa3_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa_wpa2_personal_mixed": [ + {"ssid_name": "ssid_wpa_wpa3_p_m_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_wpa3_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], "security_key": "something"}] }, "rf": {}, @@ -215,7 +219,6 @@ setup_params_general_two = { } -@pytest.mark.shivam @allure.feature("BRIDGE MODE CLIENT CONNECTIVITY") @pytest.mark.parametrize( 'setup_profiles', @@ -284,7 +287,8 @@ class TestBridgeModeConnectivitySuiteTwo(object): @pytest.mark.wpa3_personal_mixed @pytest.mark.twog @allure.story('open 2.4 GHZ Band') - def test_wpa3_personal_mixed_ssid_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, update_report, + def test_wpa3_personal_mixed_ssid_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, + update_report, test_cases): profile_data = setup_params_general_two["ssid_modes"]["wpa3_personal_mixed"][0] ssid_name = profile_data["ssid_name"] @@ -312,7 +316,8 @@ class TestBridgeModeConnectivitySuiteTwo(object): @pytest.mark.wpa3_personal_mixed @pytest.mark.fiveg @allure.story('open 5 GHZ Band') - def test_wpa3_personal_mixed_ssid_5g(self, station_names_fiveg, get_lanforge_data, lf_test, test_cases, update_report): + def test_wpa3_personal_mixed_ssid_5g(self, station_names_fiveg, get_lanforge_data, lf_test, test_cases, + update_report): profile_data = setup_params_general_two["ssid_modes"]["wpa3_personal_mixed"][1] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] @@ -336,50 +341,274 @@ class TestBridgeModeConnectivitySuiteTwo(object): passes)) assert result -# setup_params_enterprise = { -# "mode": "BRIDGE", -# "ssid_modes": { -# "wpa2_enterprise": [ -# {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, -# {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], -# "security_key": "something"}], -# "wpa3_enterprise": [ -# {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, -# {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, -# -# "rf": {}, -# "radius": True -# } -# -# -# @pytest.mark.enterprise -# @pytest.mark.parametrize( -# 'setup_profiles', -# [setup_params_enterprise], -# indirect=True, -# scope="package" -# ) -# @pytest.mark.usefixtures("setup_profiles") -# class TestBridgeModeEnterprise(object): -# -# @pytest.mark.wpa2_enterprise -# @pytest.mark.twog -# def test_wpa2_enterprise_2g(self): -# # print(setup_client_connectivity) -# assert "setup_client_connectivity" -# -# @pytest.mark.wpa2_enterprise -# @pytest.mark.fiveg -# def test_wpa2_enterprise_5g(self): -# assert "setup_client_connectivity" -# -# @pytest.mark.wpa3_enterprise -# @pytest.mark.twog -# def test_wpa3_enterprise_2g(self): -# # print(setup_client_connectivity) -# assert "setup_client_connectivity" -# -# @pytest.mark.wpa3_enterprise -# @pytest.mark.fiveg -# def test_wpa3_enterprise_5g(self): -# assert "setup_client_connectivity" + @pytest.mark.wpa_wpa2_personal_mixed + @pytest.mark.twog + @allure.story('wpa wpa2 personal mixed 2.4 GHZ Band') + def test_wpa_wpa2_personal_ssid_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, update_report, + test_cases): + profile_data = setup_params_general_two["ssid_modes"]["wpa_wpa3_personal_mixed"][0] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = ["wpa3"] + mode = "BRIDGE" + band = "twog" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names_twog, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + @pytest.mark.wpa_wpa2_personal_mixed + @pytest.mark.fiveg + @allure.story('wpa wpa2 personal mixed 5 GHZ Band') + def test_wpa_wpa2_personal_ssid_5g(self, station_names_fiveg, get_lanforge_data, lf_test, test_cases, update_report): + profile_data = setup_params_general_two["ssid_modes"]["wpa_wpa3_personal_mixed"][1] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = ["wpa3"] + mode = "BRIDGE" + band = "fiveg" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names_fiveg, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + +setup_params_enterprise = { + "mode": "BRIDGE", + "ssid_modes": { + "wpa_enterprise": [ + {"ssid_name": "ssid_wpa_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa2_enterprise": [ + {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa3_enterprise": [ + {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, + + "rf": {}, + "radius": True +} + + +@pytest.mark.enterprise +@pytest.mark.parametrize( + 'setup_profiles', + [setup_params_enterprise], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_profiles") +class TestBridgeModeEnterprise(object): + + @pytest.mark.wpa_enterprise + @pytest.mark.twog + def test_wpa_enterprise_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, update_report, + test_cases, radius_info): + profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][0] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa2" + mode = "BRIDGE" + band = "twog" + vlan = 1 + ttls_passwd = radius_info["password"] + eap = "TTLS" + identity = radius_info['user'] + passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + eap=eap, ttls_passwd=ttls_passwd, identity=identity, + station_name=station_names_twog, vlan_id=vlan) + + if passes: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert passes + + @pytest.mark.wpa_enterprise + @pytest.mark.fiveg + def test_wpa_enterprise_5g(self, station_names_fiveg, setup_profiles, get_lanforge_data, lf_test, update_report, + test_cases, radius_info): + profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][1] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa2" + mode = "BRIDGE" + band = "fiveg" + vlan = 1 + ttls_passwd = radius_info["password"] + eap = "TTLS" + identity = radius_info['user'] + passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + eap=eap, ttls_passwd=ttls_passwd, identity=identity, + station_name=station_names_fiveg, vlan_id=vlan) + + if passes: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert passes + + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + def test_wpa2_enterprise_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, update_report, + test_cases, radius_info): + profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][0] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa2" + mode = "BRIDGE" + band = "twog" + vlan = 1 + ttls_passwd = radius_info["password"] + eap = "TTLS" + identity = radius_info['user'] + passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + eap=eap, ttls_passwd=ttls_passwd, identity=identity, + station_name=station_names_twog, vlan_id=vlan) + + if passes: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert passes + + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + def test_wpa2_enterprise_5g(self, station_names_fiveg, setup_profiles, get_lanforge_data, lf_test, update_report, + test_cases, radius_info): + profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][1] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa2" + mode = "BRIDGE" + band = "fiveg" + vlan = 1 + ttls_passwd = radius_info["password"] + eap = "TTLS" + identity = radius_info['user'] + passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + eap=eap, ttls_passwd=ttls_passwd, identity=identity, + station_name=station_names_fiveg, vlan_id=vlan) + + if passes: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert passes + + @pytest.mark.wpa3_enterprise + @pytest.mark.twog + def test_wpa3_enterprise_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, update_report, + test_cases, radius_info): + profile_data = setup_params_enterprise["ssid_modes"]["wpa3_enterprise"][0] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa2" + mode = "BRIDGE" + band = "twog" + vlan = 1 + ttls_passwd = radius_info["password"] + eap = "TTLS" + identity = radius_info['user'] + passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + eap=eap, ttls_passwd=ttls_passwd, identity=identity, + station_name=station_names_twog, vlan_id=vlan) + + if passes: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert passes + + @pytest.mark.wpa3_enterprise + @pytest.mark.fiveg + def test_wpa3_enterprise_5g(self, station_names_fiveg, setup_profiles, get_lanforge_data, lf_test, update_report, + test_cases, radius_info): + profile_data = setup_params_enterprise["ssid_modes"]["wpa3_enterprise"][1] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa2" + mode = "BRIDGE" + band = "fiveg" + vlan = 1 + ttls_passwd = radius_info["password"] + eap = "TTLS" + identity = radius_info['user'] + passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + eap=eap, ttls_passwd=ttls_passwd, identity=identity, + station_name=station_names_fiveg, vlan_id=vlan) + + if passes: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert passes diff --git a/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_security_modes.py b/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_security_modes.py index 2fe3ae775..0296a284a 100644 --- a/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_security_modes.py +++ b/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_security_modes.py @@ -49,14 +49,14 @@ class TestNATModeConnectivitySuiteOne(object): station_name=station_names, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + msg='2G WPA Client Connectivity Passed successfully - NAT mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( + msg='2G WPA Client Connectivity Failed - NAT mode' + str( passes)) assert result @@ -79,14 +79,14 @@ class TestNATModeConnectivitySuiteOne(object): station_name=station_names, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + msg='2G WPA Client Connectivity Passed successfully - NAT mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( + msg='2G WPA Client Connectivity Failed - NAT mode' + str( passes)) assert result @@ -110,14 +110,14 @@ class TestNATModeConnectivitySuiteOne(object): station_name=station_names, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + msg='2G WPA Client Connectivity Passed successfully - NAT mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( + msg='2G WPA Client Connectivity Failed - NAT mode' + str( passes)) assert result @@ -140,14 +140,14 @@ class TestNATModeConnectivitySuiteOne(object): station_name=station_names, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + msg='2G WPA Client Connectivity Passed successfully - NAT mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( + msg='2G WPA Client Connectivity Failed - NAT mode' + str( passes)) assert result @@ -170,14 +170,14 @@ class TestNATModeConnectivitySuiteOne(object): station_name=station_names, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + msg='2G WPA Client Connectivity Passed successfully - NAT mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( + msg='2G WPA Client Connectivity Failed - NAT mode' + str( passes)) assert result @@ -200,14 +200,14 @@ class TestNATModeConnectivitySuiteOne(object): station_name=station_names, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + msg='2G WPA Client Connectivity Passed successfully - NAT mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( + msg='2G WPA Client Connectivity Failed - NAT mode' + str( passes)) assert result @@ -222,6 +222,10 @@ setup_params_general_two = { "wpa3_personal_mixed": [ {"ssid_name": "ssid_wpa3_p_m_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, {"ssid_name": "ssid_wpa3_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa_wpa2_personal_mixed": [ + {"ssid_name": "ssid_wpa_wpa3_p_m_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_wpa3_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], "security_key": "something"}] }, "rf": {}, @@ -260,14 +264,14 @@ class TestNATModeConnectivitySuiteTwo(object): station_name=station_names, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + msg='2G WPA Client Connectivity Passed successfully - NAT mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( + msg='2G WPA Client Connectivity Failed - NAT mode' + str( passes)) assert result @@ -290,14 +294,14 @@ class TestNATModeConnectivitySuiteTwo(object): station_name=station_names, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + msg='2G WPA Client Connectivity Passed successfully - NAT mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( + msg='2G WPA Client Connectivity Failed - NAT mode' + str( passes)) assert result @@ -321,14 +325,14 @@ class TestNATModeConnectivitySuiteTwo(object): station_name=station_names, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + msg='2G WPA Client Connectivity Passed successfully - NAT mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( + msg='2G WPA Client Connectivity Failed - NAT mode' + str( passes)) assert result @@ -350,6 +354,34 @@ class TestNATModeConnectivitySuiteTwo(object): passkey=security_key, mode=mode, band=band, station_name=station_names, vlan_id=vlan) + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - NAT mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], + status_id=5, + msg='2G WPA Client Connectivity Failed - NAT mode' + str( + passes)) + assert result + + @pytest.mark.wpa_wpa2_personal_mixed + @pytest.mark.twog + @allure.story('wpa wpa2 personal mixed 2.4 GHZ Band') + def test_wpa_wpa2_personal_ssid_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, update_report, + test_cases): + profile_data = setup_params_general_two["ssid_modes"]["wpa_wpa3_personal_mixed"][0] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = ["wpa3"] + mode = "BRIDGE" + band = "twog" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names_twog, vlan_id=vlan) + if result: update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], status_id=1, @@ -362,49 +394,246 @@ class TestNATModeConnectivitySuiteTwo(object): passes)) assert result -# setup_params_enterprise = { -# "mode": "NAT", -# "ssid_modes": { -# "wpa2_enterprise": [ -# {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, -# {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], -# "security_key": "something"}], -# "wpa3_enterprise": [ -# {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, -# {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, -# -# "rf": {}, -# "radius": True -# } -# -# -# @pytest.mark.parametrize( -# 'setup_profiles', -# [setup_params_enterprise], -# indirect=True, -# scope="package" -# ) -# @pytest.mark.usefixtures("setup_profiles") -# class TestNATModeEnterprise(object): -# -# @pytest.mark.wpa2_enterprise -# @pytest.mark.twog -# def test_wpa2_enterprise_2g(self): -# # print(setup_client_connectivity) -# assert "setup_client_connectivity" -# -# @pytest.mark.wpa2_enterprise -# @pytest.mark.fiveg -# def test_wpa2_enterprise_5g(self): -# assert "setup_client_connectivity" -# -# @pytest.mark.wpa3_enterprise -# @pytest.mark.twog -# def test_wpa3_enterprise_2g(self): -# # print(setup_client_connectivity) -# assert "setup_client_connectivity" -# -# @pytest.mark.wpa3_enterprise -# @pytest.mark.fiveg -# def test_wpa3_enterprise_5g(self): -# assert "setup_client_connectivity" + @pytest.mark.wpa_wpa2_personal_mixed + @pytest.mark.fiveg + @allure.story('wpa wpa2 personal mixed 5 GHZ Band') + def test_wpa_wpa2_personal_ssid_5g(self, station_names_fiveg, get_lanforge_data, lf_test, test_cases, update_report): + profile_data = setup_params_general_two["ssid_modes"]["wpa_wpa3_personal_mixed"][1] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = ["wpa3"] + mode = "BRIDGE" + band = "fiveg" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names_fiveg, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + +setup_params_enterprise = { + "mode": "NAT", + "ssid_modes": { + "wpa_enterprise": [ + {"ssid_name": "ssid_wpa_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa2_enterprise": [ + {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa3_enterprise": [ + {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, + + "rf": {}, + "radius": True +} + + +@pytest.mark.enterprise +@pytest.mark.parametrize( + 'setup_profiles', + [setup_params_enterprise], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_profiles") +class TestNATModeEnterprise(object): + + @pytest.mark.wpa_enterprise + @pytest.mark.twog + def test_wpa_enterprise_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, update_report, + test_cases, radius_info): + profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][0] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa2" + mode = "BRIDGE" + band = "twog" + vlan = 1 + ttls_passwd = radius_info["password"] + eap = "TTLS" + identity = radius_info['user'] + passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + eap=eap, ttls_passwd=ttls_passwd, identity=identity, + station_name=station_names_twog, vlan_id=vlan) + + if passes: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert passes + + @pytest.mark.wpa_enterprise + @pytest.mark.fiveg + def test_wpa_enterprise_5g(self, station_names_fiveg, setup_profiles, get_lanforge_data, lf_test, update_report, + test_cases, radius_info): + profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][1] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa2" + mode = "BRIDGE" + band = "fiveg" + vlan = 1 + ttls_passwd = radius_info["password"] + eap = "TTLS" + identity = radius_info['user'] + passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + eap=eap, ttls_passwd=ttls_passwd, identity=identity, + station_name=station_names_fiveg, vlan_id=vlan) + + if passes: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert passes + + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + def test_wpa2_enterprise_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, update_report, + test_cases, radius_info): + profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][0] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa2" + mode = "NAT" + band = "twog" + vlan = 1 + ttls_passwd = radius_info["password"] + eap = "TTLS" + identity = radius_info['user'] + passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + eap=eap, ttls_passwd=ttls_passwd, identity=identity, + station_name=station_names_twog, vlan_id=vlan) + + if passes: + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - NAT mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], + status_id=5, + msg='2G WPA Client Connectivity Failed - NAT mode' + str( + passes)) + assert passes + + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + def test_wpa2_enterprise_5g(self, station_names_fiveg, setup_profiles, get_lanforge_data, lf_test, update_report, + test_cases, radius_info): + profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][1] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa2" + mode = "NAT" + band = "fiveg" + vlan = 1 + ttls_passwd = radius_info["password"] + eap = "TTLS" + identity = radius_info['user'] + passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + eap=eap, ttls_passwd=ttls_passwd, identity=identity, + station_name=station_names_fiveg, vlan_id=vlan) + + if passes: + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - NAT mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], + status_id=5, + msg='2G WPA Client Connectivity Failed - NAT mode' + str( + passes)) + assert passes + + @pytest.mark.wpa3_enterprise + @pytest.mark.twog + def test_wpa3_enterprise_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, update_report, + test_cases, radius_info): + profile_data = setup_params_enterprise["ssid_modes"]["wpa3_enterprise"][0] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa2" + mode = "NAT" + band = "twog" + vlan = 1 + ttls_passwd = radius_info["password"] + eap = "TTLS" + identity = radius_info['user'] + passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + eap=eap, ttls_passwd=ttls_passwd, identity=identity, + station_name=station_names_twog, vlan_id=vlan) + + if passes: + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - NAT mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], + status_id=5, + msg='2G WPA Client Connectivity Failed - NAT mode' + str( + passes)) + assert passes + + @pytest.mark.wpa3_enterprise + @pytest.mark.fiveg + def test_wpa3_enterprise_5g(self, station_names_fiveg, setup_profiles, get_lanforge_data, lf_test, update_report, + test_cases, radius_info): + profile_data = setup_params_enterprise["ssid_modes"]["wpa3_enterprise"][1] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa2" + mode = "NAT" + band = "fiveg" + vlan = 1 + ttls_passwd = radius_info["password"] + eap = "TTLS" + identity = radius_info['user'] + passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + eap=eap, ttls_passwd=ttls_passwd, identity=identity, + station_name=station_names_fiveg, vlan_id=vlan) + + if passes: + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - NAT mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], + status_id=5, + msg='2G WPA Client Connectivity Failed - NAT mode' + str( + passes)) + assert passes diff --git a/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_security_modes.py b/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_security_modes.py index 32b67b75d..9b885dc79 100644 --- a/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_security_modes.py +++ b/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_security_modes.py @@ -49,14 +49,14 @@ class TestVLANModeConnectivity(object): station_name=station_names, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + msg='2G WPA Client Connectivity Passed successfully - VLAN mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( + msg='2G WPA Client Connectivity Failed - VLAN mode' + str( passes)) assert result @@ -79,14 +79,14 @@ class TestVLANModeConnectivity(object): station_name=station_names, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + msg='2G WPA Client Connectivity Passed successfully - VLAN mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( + msg='2G WPA Client Connectivity Failed - VLAN mode' + str( passes)) assert result @@ -110,14 +110,14 @@ class TestVLANModeConnectivity(object): station_name=station_names, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + msg='2G WPA Client Connectivity Passed successfully - VLAN mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( + msg='2G WPA Client Connectivity Failed - VLAN mode' + str( passes)) assert result @@ -140,14 +140,14 @@ class TestVLANModeConnectivity(object): station_name=station_names, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + msg='2G WPA Client Connectivity Passed successfully - VLAN mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( + msg='2G WPA Client Connectivity Failed - VLAN mode' + str( passes)) assert result @@ -170,14 +170,14 @@ class TestVLANModeConnectivity(object): station_name=station_names, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + msg='2G WPA Client Connectivity Passed successfully - VLAN mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( + msg='2G WPA Client Connectivity Failed - VLAN mode' + str( passes)) assert result @@ -200,14 +200,14 @@ class TestVLANModeConnectivity(object): station_name=station_names, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + msg='2G WPA Client Connectivity Passed successfully - VLAN mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( + msg='2G WPA Client Connectivity Failed - VLAN mode' + str( passes)) assert result @@ -222,6 +222,10 @@ setup_params_general_two = { "wpa3_personal_mixed": [ {"ssid_name": "ssid_wpa3_p_m_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, {"ssid_name": "ssid_wpa3_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa_wpa2_personal_mixed": [ + {"ssid_name": "ssid_wpa_wpa3_p_m_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_wpa3_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], "security_key": "something"}] }, "rf": {}, @@ -238,7 +242,7 @@ setup_params_general_two = { scope="class" ) @pytest.mark.usefixtures("setup_profiles") -class TestBridgeModeConnectivitySuiteTwo(object): +class TestVLANModeConnectivitySuiteTwo(object): @pytest.mark.wpa3_personal @pytest.mark.twog @@ -257,14 +261,14 @@ class TestBridgeModeConnectivitySuiteTwo(object): station_name=station_names_twog, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + msg='2G WPA Client Connectivity Passed successfully - VLAN mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( + msg='2G WPA Client Connectivity Failed - VLAN mode' + str( passes)) assert result @@ -287,21 +291,22 @@ class TestBridgeModeConnectivitySuiteTwo(object): station_name=station_names, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + msg='2G WPA Client Connectivity Passed successfully - VLAN mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( + msg='2G WPA Client Connectivity Failed - VLAN mode' + str( passes)) assert result @pytest.mark.wpa3_personal_mixed @pytest.mark.twog @allure.story('open 2.4 GHZ Band') - def test_wpa3_personal_mixed_ssid_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, update_report, + def test_wpa3_personal_mixed_ssid_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, + update_report, test_cases): profile_data = setup_params_general_two["ssid_modes"]["wpa3_personal_mixed"][0] ssid_name = profile_data["ssid_name"] @@ -315,14 +320,14 @@ class TestBridgeModeConnectivitySuiteTwo(object): station_name=station_names_twog, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + msg='2G WPA Client Connectivity Passed successfully - VLAN mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( + msg='2G WPA Client Connectivity Failed - VLAN mode' + str( passes)) assert result @@ -344,6 +349,61 @@ class TestBridgeModeConnectivitySuiteTwo(object): passkey=security_key, mode=mode, band=band, station_name=station_names, vlan_id=vlan) + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - VLAN mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], + status_id=5, + msg='2G WPA Client Connectivity Failed - VLAN mode' + str( + passes)) + assert result + + @pytest.mark.wpa_wpa2_personal_mixed + @pytest.mark.twog + @allure.story('wpa wpa2 personal mixed 2.4 GHZ Band') + def test_wpa_wpa2_personal_ssid_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, update_report, + test_cases): + profile_data = setup_params_general_two["ssid_modes"]["wpa_wpa3_personal_mixed"][0] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = ["wpa3"] + mode = "BRIDGE" + band = "twog" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names_twog, vlan_id=vlan) + + if result: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert result + + @pytest.mark.wpa_wpa2_personal_mixed + @pytest.mark.fiveg + @allure.story('wpa wpa2 personal mixed 5 GHZ Band') + def test_wpa_wpa2_personal_ssid_5g(self, station_names_fiveg, get_lanforge_data, lf_test, test_cases, update_report): + profile_data = setup_params_general_two["ssid_modes"]["wpa_wpa3_personal_mixed"][1] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = ["wpa3"] + mode = "BRIDGE" + band = "fiveg" + vlan = 1 + passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + station_name=station_names_fiveg, vlan_id=vlan) + if result: update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], status_id=1, @@ -357,10 +417,13 @@ class TestBridgeModeConnectivitySuiteTwo(object): assert result - setup_params_enterprise = { "mode": "VLAN", "ssid_modes": { + "wpa_enterprise": [ + {"ssid_name": "ssid_wpa_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], "wpa2_enterprise": [ {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], @@ -373,35 +436,199 @@ setup_params_enterprise = { "radius": True } -# -# @pytest.mark.parametrize( -# 'setup_profiles', -# -# [setup_params_enterprise], -# indirect=True, -# scope="package" -# ) -# @pytest.mark.usefixtures("setup_profiles") -# class TestBridgeModeEnterprise(object): -# -# @pytest.mark.wpa2_enterprise -# @pytest.mark.twog -# def test_wpa2_enterprise_2g(self, ): -# # print(setup_client_connectivity) -# assert "setup_client_connectivity" -# -# @pytest.mark.wpa2_enterprise -# @pytest.mark.fiveg -# def test_wpa2_enterprise_5g(self): -# assert "setup_client_connectivity" -# -# @pytest.mark.wpa3_enterprise -# @pytest.mark.twog -# def test_wpa3_enterprise_2g(self): -# # print(setup_client_connectivity) -# assert "setup_client_connectivity" -# -# @pytest.mark.wpa3_enterprise -# @pytest.mark.fiveg -# def test_wpa3_enterprise_5g(self): -# assert "setup_client_connectivity" + +@pytest.mark.enterprise +@pytest.mark.parametrize( + 'setup_profiles', + [setup_params_enterprise], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_profiles") +class TestVLANModeEnterprise(object): + + @pytest.mark.wpa_enterprise + @pytest.mark.twog + def test_wpa_enterprise_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, update_report, + test_cases, radius_info): + profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][0] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa2" + mode = "BRIDGE" + band = "twog" + vlan = 1 + ttls_passwd = radius_info["password"] + eap = "TTLS" + identity = radius_info['user'] + passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + eap=eap, ttls_passwd=ttls_passwd, identity=identity, + station_name=station_names_twog, vlan_id=vlan) + + if passes: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert passes + + @pytest.mark.wpa_enterprise + @pytest.mark.fiveg + def test_wpa_enterprise_5g(self, station_names_fiveg, setup_profiles, get_lanforge_data, lf_test, update_report, + test_cases, radius_info): + profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][1] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa2" + mode = "BRIDGE" + band = "fiveg" + vlan = 1 + ttls_passwd = radius_info["password"] + eap = "TTLS" + identity = radius_info['user'] + passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + eap=eap, ttls_passwd=ttls_passwd, identity=identity, + station_name=station_names_fiveg, vlan_id=vlan) + + if passes: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + status_id=5, + msg='2G WPA Client Connectivity Failed - bridge mode' + str( + passes)) + assert passes + + @pytest.mark.wpa2_enterprise + @pytest.mark.twog + def test_wpa2_enterprise_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, update_report, + test_cases, radius_info): + profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][0] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa2" + mode = "VLAN" + band = "twog" + vlan = 1 + ttls_passwd = radius_info["password"] + eap = "TTLS" + identity = radius_info['user'] + passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + eap=eap, ttls_passwd=ttls_passwd, identity=identity, + station_name=station_names_twog, vlan_id=vlan) + + if passes: + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - VLAN mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], + status_id=5, + msg='2G WPA Client Connectivity Failed - VLAN mode' + str( + passes)) + assert passes + + @pytest.mark.wpa2_enterprise + @pytest.mark.fiveg + def test_wpa2_enterprise_5g(self, station_names_fiveg, setup_profiles, get_lanforge_data, lf_test, update_report, + test_cases, radius_info): + profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][1] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa2" + mode = "VLAN" + band = "fiveg" + vlan = 1 + ttls_passwd = radius_info["password"] + eap = "TTLS" + identity = radius_info['user'] + passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + eap=eap, ttls_passwd=ttls_passwd, identity=identity, + station_name=station_names_fiveg, vlan_id=vlan) + + if passes: + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - VLAN mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], + status_id=5, + msg='2G WPA Client Connectivity Failed - VLAN mode' + str( + passes)) + assert passes + + @pytest.mark.wpa3_enterprise + @pytest.mark.twog + def test_wpa3_enterprise_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, update_report, + test_cases, radius_info): + profile_data = setup_params_enterprise["ssid_modes"]["wpa3_enterprise"][0] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa2" + mode = "VLAN" + band = "twog" + vlan = 1 + ttls_passwd = radius_info["password"] + eap = "TTLS" + identity = radius_info['user'] + passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + eap=eap, ttls_passwd=ttls_passwd, identity=identity, + station_name=station_names_twog, vlan_id=vlan) + + if passes: + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - VLAN mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], + status_id=5, + msg='2G WPA Client Connectivity Failed - VLAN mode' + str( + passes)) + assert passes + + @pytest.mark.wpa3_enterprise + @pytest.mark.fiveg + def test_wpa3_enterprise_5g(self, station_names_fiveg, setup_profiles, get_lanforge_data, lf_test, update_report, + test_cases, radius_info): + profile_data = setup_params_enterprise["ssid_modes"]["wpa3_enterprise"][1] + ssid_name = profile_data["ssid_name"] + security_key = profile_data["security_key"] + security = "wpa2" + mode = "VLAN" + band = "fiveg" + vlan = 1 + ttls_passwd = radius_info["password"] + eap = "TTLS" + identity = radius_info['user'] + passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, + passkey=security_key, mode=mode, band=band, + eap=eap, ttls_passwd=ttls_passwd, identity=identity, + station_name=station_names_fiveg, vlan_id=vlan) + + if passes: + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], + status_id=1, + msg='2G WPA Client Connectivity Passed successfully - VLAN mode' + str( + passes)) + else: + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], + status_id=5, + msg='2G WPA Client Connectivity Failed - VLAN mode' + str( + passes)) + assert passes From 60396d2df43e81af871791552f255125f1eb6ba2 Mon Sep 17 00:00:00 2001 From: shivamcandela Date: Thu, 20 May 2021 19:07:53 +0530 Subject: [PATCH 17/21] added e2e configuration Signed-off-by: shivamcandela --- .../test_bridge_mode_configuration.py | 198 +++++++++++++++++ .../nat_mode/test_nat_mode_configuration.py | 203 ++++++++++++++++- .../vlan_mode/test_vlan_mode_configuration.py | 207 +++++++++++++++++- 3 files changed, 600 insertions(+), 8 deletions(-) diff --git a/tests/e2e/basic/configuration_tests/bridge_mode/test_bridge_mode_configuration.py b/tests/e2e/basic/configuration_tests/bridge_mode/test_bridge_mode_configuration.py index 2fafaca92..0ea6e63ff 100644 --- a/tests/e2e/basic/configuration_tests/bridge_mode/test_bridge_mode_configuration.py +++ b/tests/e2e/basic/configuration_tests/bridge_mode/test_bridge_mode_configuration.py @@ -166,9 +166,178 @@ class TestSetupBridge(object): assert False +setup_params_general_two = { + "mode": "BRIDGE", + "ssid_modes": { + "wpa3_personal": [ + {"ssid_name": "ssid_wpa3_p_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa3_p_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa3_personal_mixed": [ + {"ssid_name": "ssid_wpa3_p_m_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa3_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa_wpa2_personal_mixed": [ + {"ssid_name": "ssid_wpa_wpa3_p_m_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_wpa3_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}] + }, + "rf": {}, + "radius": False +} + + +@allure.feature("BRIDGE MODE CLIENT CONNECTIVITY") +@pytest.mark.parametrize( + 'setup_profiles', + [setup_params_general_two], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_profiles") +class TestBridgeModeConnectivitySuiteTwo(object): + + @pytest.mark.wpa3_personal + @pytest.mark.twog + def test_setup_wpa3_personal_2g_ssid_profile(self, setup_profiles, update_report, test_cases): + if setup_profiles['open_2g']: + update_report.update_testrail(case_id=test_cases["open_2g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['open_2g'] + else: + update_report.update_testrail(case_id=test_cases["open_2g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa3_personal + @pytest.mark.fiveg + def test_setup_wpa3_personal_5g_ssid_profile(self, setup_profiles, update_report, test_cases): + + if setup_profiles['open_5g']: + update_report.update_testrail(case_id=test_cases["open_5g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['open_5g'] + else: + update_report.update_testrail(case_id=test_cases["open_5g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa3_personal_mixed + @pytest.mark.twog + def test_setup_wpa3_personal_mixed_2g_ssid_profile(self, setup_profiles, update_report, test_cases): + if setup_profiles['wpa_2g']: + update_report.update_testrail(case_id=test_cases["wpa_2g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa_2g'] + else: + update_report.update_testrail(case_id=test_cases["wpa_2g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa3_personal_mixed + @pytest.mark.fiveg + def test_setup_wpa3_personal_mixed_5g_ssid_profile(self, setup_profiles, update_report, test_cases): + + if setup_profiles['wpa_5g']: + update_report.update_testrail(case_id=test_cases["wpa_5g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa_5g'] + else: + update_report.update_testrail(case_id=test_cases["wpa_5g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa_wpa2_personal_mixed + @pytest.mark.twog + def test_setup_wpa_wpa2_personal_mixed_2g_ssid_profile(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['wpa2_personal_2g']: + update_report.update_testrail(case_id=test_cases["wpa2_personal_2g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa2_personal_2g'] + else: + update_report.update_testrail(case_id=test_cases["wpa2_personal_2g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa_wpa2_personal_mixed + @pytest.mark.fiveg + def test_setup_wpa_wpa2_personal_mixed_5g_ssid_profile(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['wpa2_personal_5g']: + update_report.update_testrail(case_id=test_cases["wpa2_personal_5g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa2_personal_5g'] + else: + update_report.update_testrail(case_id=test_cases["wpa2_personal_5g"], + status_id=5, + msg='Failed to create profile') + assert False + + def test_setup_equipment_ap_profile(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['equipment_ap']: + update_report.update_testrail(case_id=test_cases["equipment_ap"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['equipment_ap'] + else: + update_report.update_testrail(case_id=test_cases["equipment_ap"], + status_id=5, + msg='Failed to create profile') + assert False + + def test_verify_vif_config(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['vifc']: + update_report.update_testrail(case_id=test_cases["vifc"], + status_id=1, + msg='profile pushed successfully') + assert setup_profiles['vifc'] + else: + update_report.update_testrail(case_id=test_cases["vifc"], + status_id=5, + msg='Failed to push profile') + assert False + + def test_verify_vif_state(self, setup_profiles, update_report, + test_cases): + if setup_profiles['vifs']: + update_report.update_testrail(case_id=test_cases["vifs"], + status_id=1, + msg='profile pushed successfully') + time.sleep(100) + assert setup_profiles['vifs'] + else: + update_report.update_testrail(case_id=test_cases["vifs"], + status_id=5, + msg='Failed to push profile') + time.sleep(100) + assert False + + setup_params_enterprise = { "mode": "BRIDGE", "ssid_modes": { + "wpa_enterprise": [ + {"ssid_name": "ssid_wpa_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], "wpa2_enterprise": [ {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], @@ -193,6 +362,35 @@ setup_params_enterprise = { @pytest.mark.usefixtures("setup_profiles") class TestSetupBridgeEnterprise(object): + @pytest.mark.wpa_enterprise + @pytest.mark.twog + def test_setup_wpa2_enterprise_2g_ssid_profile(self, setup_profiles, update_report, test_cases): + if setup_profiles['wpa_enterprise_2g']: + update_report.update_testrail(case_id=test_cases["wpa2_enterprise_2g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa2_enterprise_2g'] + else: + update_report.update_testrail(case_id=test_cases["wpa2_enterprise_2g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa_enterprise + @pytest.mark.fiveg + def test_setup_wpa2_enterprise_5g_ssid_profile(self, setup_profiles, update_report, test_cases): + + if setup_profiles['wpa_enterprise_5g']: + update_report.update_testrail(case_id=test_cases["wpa2_enterprise_5g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa2_enterprise_5g'] + else: + update_report.update_testrail(case_id=test_cases["wpa2_enterprise_5g"], + status_id=5, + msg='Failed to create profile') + assert False + @pytest.mark.wpa2_enterprise @pytest.mark.twog def test_setup_wpa2_enterprise_2g_ssid_profile(self, setup_profiles, update_report, test_cases): diff --git a/tests/e2e/basic/configuration_tests/nat_mode/test_nat_mode_configuration.py b/tests/e2e/basic/configuration_tests/nat_mode/test_nat_mode_configuration.py index aa5ce5b3a..4112ff575 100644 --- a/tests/e2e/basic/configuration_tests/nat_mode/test_nat_mode_configuration.py +++ b/tests/e2e/basic/configuration_tests/nat_mode/test_nat_mode_configuration.py @@ -2,7 +2,7 @@ import allure import pytest import time -pytestmark = [pytest.mark.setup, pytest.mark.nat, pytest.mark.sanity] +pytestmark = [pytest.mark.setup, pytest.mark.NAT, pytest.mark.sanity] setup_params_general = { "mode": "NAT", @@ -22,7 +22,7 @@ setup_params_general = { @pytest.mark.basic -@allure.feature("BRIDGE MODE SETUP") +@allure.feature("NAT MODE SETUP") @pytest.mark.parametrize( 'setup_profiles', [setup_params_general], @@ -166,9 +166,178 @@ class TestSetupNAT(object): assert False +setup_params_general_two = { + "mode": "NAT", + "ssid_modes": { + "wpa3_personal": [ + {"ssid_name": "ssid_wpa3_p_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa3_p_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa3_personal_mixed": [ + {"ssid_name": "ssid_wpa3_p_m_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa3_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa_wpa2_personal_mixed": [ + {"ssid_name": "ssid_wpa_wpa3_p_m_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_wpa3_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}] + }, + "rf": {}, + "radius": False +} + + +@allure.feature("NAT MODE CLIENT CONNECTIVITY") +@pytest.mark.parametrize( + 'setup_profiles', + [setup_params_general_two], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_profiles") +class TestNATModeConnectivitySuiteTwo(object): + + @pytest.mark.wpa3_personal + @pytest.mark.twog + def test_setup_wpa3_personal_2g_ssid_profile(self, setup_profiles, update_report, test_cases): + if setup_profiles['open_2g']: + update_report.update_testrail(case_id=test_cases["open_2g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['open_2g'] + else: + update_report.update_testrail(case_id=test_cases["open_2g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa3_personal + @pytest.mark.fiveg + def test_setup_wpa3_personal_5g_ssid_profile(self, setup_profiles, update_report, test_cases): + + if setup_profiles['open_5g']: + update_report.update_testrail(case_id=test_cases["open_5g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['open_5g'] + else: + update_report.update_testrail(case_id=test_cases["open_5g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa3_personal_mixed + @pytest.mark.twog + def test_setup_wpa3_personal_mixed_2g_ssid_profile(self, setup_profiles, update_report, test_cases): + if setup_profiles['wpa_2g']: + update_report.update_testrail(case_id=test_cases["wpa_2g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa_2g'] + else: + update_report.update_testrail(case_id=test_cases["wpa_2g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa3_personal_mixed + @pytest.mark.fiveg + def test_setup_wpa3_personal_mixed_5g_ssid_profile(self, setup_profiles, update_report, test_cases): + + if setup_profiles['wpa_5g']: + update_report.update_testrail(case_id=test_cases["wpa_5g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa_5g'] + else: + update_report.update_testrail(case_id=test_cases["wpa_5g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa_wpa2_personal_mixed + @pytest.mark.twog + def test_setup_wpa_wpa2_personal_mixed_2g_ssid_profile(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['wpa2_personal_2g']: + update_report.update_testrail(case_id=test_cases["wpa2_personal_2g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa2_personal_2g'] + else: + update_report.update_testrail(case_id=test_cases["wpa2_personal_2g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa_wpa2_personal_mixed + @pytest.mark.fiveg + def test_setup_wpa_wpa2_personal_mixed_5g_ssid_profile(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['wpa2_personal_5g']: + update_report.update_testrail(case_id=test_cases["wpa2_personal_5g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa2_personal_5g'] + else: + update_report.update_testrail(case_id=test_cases["wpa2_personal_5g"], + status_id=5, + msg='Failed to create profile') + assert False + + def test_setup_equipment_ap_profile(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['equipment_ap']: + update_report.update_testrail(case_id=test_cases["equipment_ap"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['equipment_ap'] + else: + update_report.update_testrail(case_id=test_cases["equipment_ap"], + status_id=5, + msg='Failed to create profile') + assert False + + def test_verify_vif_config(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['vifc']: + update_report.update_testrail(case_id=test_cases["vifc"], + status_id=1, + msg='profile pushed successfully') + assert setup_profiles['vifc'] + else: + update_report.update_testrail(case_id=test_cases["vifc"], + status_id=5, + msg='Failed to push profile') + assert False + + def test_verify_vif_state(self, setup_profiles, update_report, + test_cases): + if setup_profiles['vifs']: + update_report.update_testrail(case_id=test_cases["vifs"], + status_id=1, + msg='profile pushed successfully') + time.sleep(100) + assert setup_profiles['vifs'] + else: + update_report.update_testrail(case_id=test_cases["vifs"], + status_id=5, + msg='Failed to push profile') + time.sleep(100) + assert False + + setup_params_enterprise = { "mode": "NAT", "ssid_modes": { + "wpa_enterprise": [ + {"ssid_name": "ssid_wpa_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], "wpa2_enterprise": [ {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], @@ -181,7 +350,6 @@ setup_params_enterprise = { "radius": True } - @pytest.mark.enterprise @allure.feature("NAT MODE ENTERPRISE SETUP") @pytest.mark.parametrize( @@ -193,6 +361,35 @@ setup_params_enterprise = { @pytest.mark.usefixtures("setup_profiles") class TestSetupNATEnterprise(object): + @pytest.mark.wpa_enterprise + @pytest.mark.twog + def test_setup_wpa2_enterprise_2g_ssid_profile(self, setup_profiles, update_report, test_cases): + if setup_profiles['wpa_enterprise_2g']: + update_report.update_testrail(case_id=test_cases["wpa2_enterprise_2g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa2_enterprise_2g'] + else: + update_report.update_testrail(case_id=test_cases["wpa2_enterprise_2g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa_enterprise + @pytest.mark.fiveg + def test_setup_wpa2_enterprise_5g_ssid_profile(self, setup_profiles, update_report, test_cases): + + if setup_profiles['wpa_enterprise_5g']: + update_report.update_testrail(case_id=test_cases["wpa2_enterprise_5g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa2_enterprise_5g'] + else: + update_report.update_testrail(case_id=test_cases["wpa2_enterprise_5g"], + status_id=5, + msg='Failed to create profile') + assert False + @pytest.mark.wpa2_enterprise @pytest.mark.twog def test_setup_wpa2_enterprise_2g_ssid_profile(self, setup_profiles, update_report, test_cases): diff --git a/tests/e2e/basic/configuration_tests/vlan_mode/test_vlan_mode_configuration.py b/tests/e2e/basic/configuration_tests/vlan_mode/test_vlan_mode_configuration.py index 9c61b3339..58e07d16e 100644 --- a/tests/e2e/basic/configuration_tests/vlan_mode/test_vlan_mode_configuration.py +++ b/tests/e2e/basic/configuration_tests/vlan_mode/test_vlan_mode_configuration.py @@ -2,7 +2,7 @@ import allure import pytest import time -pytestmark = [pytest.mark.setup, pytest.mark.vlan, pytest.mark.sanity] +pytestmark = [pytest.mark.setup, pytest.mark.VLAN, pytest.mark.sanity] setup_params_general = { "mode": "VLAN", @@ -22,7 +22,7 @@ setup_params_general = { @pytest.mark.basic -@allure.feature("BRIDGE MODE SETUP") +@allure.feature("VLAN MODE SETUP") @pytest.mark.parametrize( 'setup_profiles', [setup_params_general], @@ -30,7 +30,7 @@ setup_params_general = { scope="class" ) @pytest.mark.usefixtures("setup_profiles") -class TestSetupVlan(object): +class TestSetupVLAN(object): @pytest.mark.open @pytest.mark.twog @@ -166,9 +166,178 @@ class TestSetupVlan(object): assert False +setup_params_general_two = { + "mode": "VLAN", + "ssid_modes": { + "wpa3_personal": [ + {"ssid_name": "ssid_wpa3_p_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa3_p_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa3_personal_mixed": [ + {"ssid_name": "ssid_wpa3_p_m_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa3_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], + "wpa_wpa2_personal_mixed": [ + {"ssid_name": "ssid_wpa_wpa3_p_m_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_wpa3_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}] + }, + "rf": {}, + "radius": False +} + + +@allure.feature("VLAN MODE CLIENT CONNECTIVITY") +@pytest.mark.parametrize( + 'setup_profiles', + [setup_params_general_two], + indirect=True, + scope="class" +) +@pytest.mark.usefixtures("setup_profiles") +class TestVLANModeConnectivitySuiteTwo(object): + + @pytest.mark.wpa3_personal + @pytest.mark.twog + def test_setup_wpa3_personal_2g_ssid_profile(self, setup_profiles, update_report, test_cases): + if setup_profiles['open_2g']: + update_report.update_testrail(case_id=test_cases["open_2g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['open_2g'] + else: + update_report.update_testrail(case_id=test_cases["open_2g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa3_personal + @pytest.mark.fiveg + def test_setup_wpa3_personal_5g_ssid_profile(self, setup_profiles, update_report, test_cases): + + if setup_profiles['open_5g']: + update_report.update_testrail(case_id=test_cases["open_5g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['open_5g'] + else: + update_report.update_testrail(case_id=test_cases["open_5g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa3_personal_mixed + @pytest.mark.twog + def test_setup_wpa3_personal_mixed_2g_ssid_profile(self, setup_profiles, update_report, test_cases): + if setup_profiles['wpa_2g']: + update_report.update_testrail(case_id=test_cases["wpa_2g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa_2g'] + else: + update_report.update_testrail(case_id=test_cases["wpa_2g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa3_personal_mixed + @pytest.mark.fiveg + def test_setup_wpa3_personal_mixed_5g_ssid_profile(self, setup_profiles, update_report, test_cases): + + if setup_profiles['wpa_5g']: + update_report.update_testrail(case_id=test_cases["wpa_5g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa_5g'] + else: + update_report.update_testrail(case_id=test_cases["wpa_5g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa_wpa2_personal_mixed + @pytest.mark.twog + def test_setup_wpa_wpa2_personal_mixed_2g_ssid_profile(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['wpa2_personal_2g']: + update_report.update_testrail(case_id=test_cases["wpa2_personal_2g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa2_personal_2g'] + else: + update_report.update_testrail(case_id=test_cases["wpa2_personal_2g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa_wpa2_personal_mixed + @pytest.mark.fiveg + def test_setup_wpa_wpa2_personal_mixed_5g_ssid_profile(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['wpa2_personal_5g']: + update_report.update_testrail(case_id=test_cases["wpa2_personal_5g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa2_personal_5g'] + else: + update_report.update_testrail(case_id=test_cases["wpa2_personal_5g"], + status_id=5, + msg='Failed to create profile') + assert False + + def test_setup_equipment_ap_profile(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['equipment_ap']: + update_report.update_testrail(case_id=test_cases["equipment_ap"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['equipment_ap'] + else: + update_report.update_testrail(case_id=test_cases["equipment_ap"], + status_id=5, + msg='Failed to create profile') + assert False + + def test_verify_vif_config(self, setup_profiles, update_report, + test_cases): + + if setup_profiles['vifc']: + update_report.update_testrail(case_id=test_cases["vifc"], + status_id=1, + msg='profile pushed successfully') + assert setup_profiles['vifc'] + else: + update_report.update_testrail(case_id=test_cases["vifc"], + status_id=5, + msg='Failed to push profile') + assert False + + def test_verify_vif_state(self, setup_profiles, update_report, + test_cases): + if setup_profiles['vifs']: + update_report.update_testrail(case_id=test_cases["vifs"], + status_id=1, + msg='profile pushed successfully') + time.sleep(100) + assert setup_profiles['vifs'] + else: + update_report.update_testrail(case_id=test_cases["vifs"], + status_id=5, + msg='Failed to push profile') + time.sleep(100) + assert False + + setup_params_enterprise = { "mode": "VLAN", "ssid_modes": { + "wpa_enterprise": [ + {"ssid_name": "ssid_wpa_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + "security_key": "something"}], "wpa2_enterprise": [ {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], @@ -181,7 +350,6 @@ setup_params_enterprise = { "radius": True } - @pytest.mark.enterprise @allure.feature("VLAN MODE ENTERPRISE SETUP") @pytest.mark.parametrize( @@ -191,7 +359,36 @@ setup_params_enterprise = { scope="class" ) @pytest.mark.usefixtures("setup_profiles") -class TestSetupVlanEnterprise(object): +class TestSetupVLANEnterprise(object): + + @pytest.mark.wpa_enterprise + @pytest.mark.twog + def test_setup_wpa2_enterprise_2g_ssid_profile(self, setup_profiles, update_report, test_cases): + if setup_profiles['wpa_enterprise_2g']: + update_report.update_testrail(case_id=test_cases["wpa2_enterprise_2g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa2_enterprise_2g'] + else: + update_report.update_testrail(case_id=test_cases["wpa2_enterprise_2g"], + status_id=5, + msg='Failed to create profile') + assert False + + @pytest.mark.wpa_enterprise + @pytest.mark.fiveg + def test_setup_wpa2_enterprise_5g_ssid_profile(self, setup_profiles, update_report, test_cases): + + if setup_profiles['wpa_enterprise_5g']: + update_report.update_testrail(case_id=test_cases["wpa2_enterprise_5g"], + status_id=1, + msg='profile created successfully') + assert setup_profiles['wpa2_enterprise_5g'] + else: + update_report.update_testrail(case_id=test_cases["wpa2_enterprise_5g"], + status_id=5, + msg='Failed to create profile') + assert False @pytest.mark.wpa2_enterprise @pytest.mark.twog From 1d218cf6fc840c8f3dc548148af03a47148bcd09 Mon Sep 17 00:00:00 2001 From: shivamcandela Date: Fri, 21 May 2021 17:03:40 +0530 Subject: [PATCH 18/21] security mode test case fixes and configuration added Signed-off-by: shivamcandela --- tests/conftest.py | 2 +- .../test_bridge_mode_configuration.py | 22 +- .../nat_mode/test_nat_mode_configuration.py | 27 +- .../vlan_mode/test_vlan_mode_configuration.py | 27 +- tests/e2e/basic/conftest.py | 35 +- .../test_security_modes.py | 173 +++++---- .../test_security_modes.py | 336 ++++++++---------- .../test_security_modes.py | 335 ++++++++--------- 8 files changed, 461 insertions(+), 496 deletions(-) diff --git a/tests/conftest.py b/tests/conftest.py index a8ba995df..cbf34cc39 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -305,7 +305,7 @@ FRAMEWORK MARKER LOGIC def get_security_flags(): # Add more classifications as we go security = ["open", "wpa", "wpa2_personal", "wpa3_personal", "wpa3_personal_mixed", - "wpa2_enterprise", "wpa3_enterprise", "twog", "fiveg", "radius"] + "wpa_wpa2_personal_mixed", "wpa2_enterprise", "wpa3_enterprise", "twog", "fiveg", "radius"] yield security diff --git a/tests/e2e/basic/configuration_tests/bridge_mode/test_bridge_mode_configuration.py b/tests/e2e/basic/configuration_tests/bridge_mode/test_bridge_mode_configuration.py index 0ea6e63ff..889b2cd63 100644 --- a/tests/e2e/basic/configuration_tests/bridge_mode/test_bridge_mode_configuration.py +++ b/tests/e2e/basic/configuration_tests/bridge_mode/test_bridge_mode_configuration.py @@ -178,8 +178,8 @@ setup_params_general_two = { {"ssid_name": "ssid_wpa3_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], "security_key": "something"}], "wpa_wpa2_personal_mixed": [ - {"ssid_name": "ssid_wpa_wpa3_p_m_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa_wpa3_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + {"ssid_name": "ssid_wpa_wpa2_p_m_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_wpa2_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], "security_key": "something"}] }, "rf": {}, @@ -261,12 +261,12 @@ class TestBridgeModeConnectivitySuiteTwo(object): test_cases): if setup_profiles['wpa2_personal_2g']: - update_report.update_testrail(case_id=test_cases["wpa2_personal_2g"], + update_report.update_testrail(case_id=test_cases["wpa_wpa2_personal_mixed_2g"], status_id=1, msg='profile created successfully') assert setup_profiles['wpa2_personal_2g'] else: - update_report.update_testrail(case_id=test_cases["wpa2_personal_2g"], + update_report.update_testrail(case_id=test_cases["wpa_wpa2_personal_mixed_2g"], status_id=5, msg='Failed to create profile') assert False @@ -277,12 +277,12 @@ class TestBridgeModeConnectivitySuiteTwo(object): test_cases): if setup_profiles['wpa2_personal_5g']: - update_report.update_testrail(case_id=test_cases["wpa2_personal_5g"], + update_report.update_testrail(case_id=test_cases["wpa_wpa2_personal_mixed_5g"], status_id=1, msg='profile created successfully') assert setup_profiles['wpa2_personal_5g'] else: - update_report.update_testrail(case_id=test_cases["wpa2_personal_5g"], + update_report.update_testrail(case_id=test_cases["wpa_wpa2_personal_mixed_5g"], status_id=5, msg='Failed to create profile') assert False @@ -335,13 +335,11 @@ setup_params_enterprise = { "mode": "BRIDGE", "ssid_modes": { "wpa_enterprise": [ - {"ssid_name": "ssid_wpa_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}], + {"ssid_name": "ssid_wpa_eap_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_wpa_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], "wpa2_enterprise": [ - {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}], + {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], "wpa3_enterprise": [ {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, diff --git a/tests/e2e/basic/configuration_tests/nat_mode/test_nat_mode_configuration.py b/tests/e2e/basic/configuration_tests/nat_mode/test_nat_mode_configuration.py index 4112ff575..25bee54d5 100644 --- a/tests/e2e/basic/configuration_tests/nat_mode/test_nat_mode_configuration.py +++ b/tests/e2e/basic/configuration_tests/nat_mode/test_nat_mode_configuration.py @@ -178,8 +178,8 @@ setup_params_general_two = { {"ssid_name": "ssid_wpa3_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], "security_key": "something"}], "wpa_wpa2_personal_mixed": [ - {"ssid_name": "ssid_wpa_wpa3_p_m_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa_wpa3_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + {"ssid_name": "ssid_wpa_wpa2_p_m_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_wpa2_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], "security_key": "something"}] }, "rf": {}, @@ -258,15 +258,15 @@ class TestNATModeConnectivitySuiteTwo(object): @pytest.mark.wpa_wpa2_personal_mixed @pytest.mark.twog def test_setup_wpa_wpa2_personal_mixed_2g_ssid_profile(self, setup_profiles, update_report, - test_cases): + test_cases): if setup_profiles['wpa2_personal_2g']: - update_report.update_testrail(case_id=test_cases["wpa2_personal_2g"], + update_report.update_testrail(case_id=test_cases["wpa_wpa2_personal_mixed_2g"], status_id=1, msg='profile created successfully') assert setup_profiles['wpa2_personal_2g'] else: - update_report.update_testrail(case_id=test_cases["wpa2_personal_2g"], + update_report.update_testrail(case_id=test_cases["wpa_wpa2_personal_mixed_2g"], status_id=5, msg='Failed to create profile') assert False @@ -274,15 +274,15 @@ class TestNATModeConnectivitySuiteTwo(object): @pytest.mark.wpa_wpa2_personal_mixed @pytest.mark.fiveg def test_setup_wpa_wpa2_personal_mixed_5g_ssid_profile(self, setup_profiles, update_report, - test_cases): + test_cases): if setup_profiles['wpa2_personal_5g']: - update_report.update_testrail(case_id=test_cases["wpa2_personal_5g"], + update_report.update_testrail(case_id=test_cases["wpa_wpa2_personal_mixed_5g"], status_id=1, msg='profile created successfully') assert setup_profiles['wpa2_personal_5g'] else: - update_report.update_testrail(case_id=test_cases["wpa2_personal_5g"], + update_report.update_testrail(case_id=test_cases["wpa_wpa2_personal_mixed_5g"], status_id=5, msg='Failed to create profile') assert False @@ -335,13 +335,11 @@ setup_params_enterprise = { "mode": "NAT", "ssid_modes": { "wpa_enterprise": [ - {"ssid_name": "ssid_wpa_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}], + {"ssid_name": "ssid_wpa_eap_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_wpa_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], "wpa2_enterprise": [ - {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}], + {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], "wpa3_enterprise": [ {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, @@ -350,6 +348,7 @@ setup_params_enterprise = { "radius": True } + @pytest.mark.enterprise @allure.feature("NAT MODE ENTERPRISE SETUP") @pytest.mark.parametrize( diff --git a/tests/e2e/basic/configuration_tests/vlan_mode/test_vlan_mode_configuration.py b/tests/e2e/basic/configuration_tests/vlan_mode/test_vlan_mode_configuration.py index 58e07d16e..938657140 100644 --- a/tests/e2e/basic/configuration_tests/vlan_mode/test_vlan_mode_configuration.py +++ b/tests/e2e/basic/configuration_tests/vlan_mode/test_vlan_mode_configuration.py @@ -178,8 +178,8 @@ setup_params_general_two = { {"ssid_name": "ssid_wpa3_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], "security_key": "something"}], "wpa_wpa2_personal_mixed": [ - {"ssid_name": "ssid_wpa_wpa3_p_m_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa_wpa3_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + {"ssid_name": "ssid_wpa_wpa2_p_m_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_wpa2_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], "security_key": "something"}] }, "rf": {}, @@ -258,15 +258,15 @@ class TestVLANModeConnectivitySuiteTwo(object): @pytest.mark.wpa_wpa2_personal_mixed @pytest.mark.twog def test_setup_wpa_wpa2_personal_mixed_2g_ssid_profile(self, setup_profiles, update_report, - test_cases): + test_cases): if setup_profiles['wpa2_personal_2g']: - update_report.update_testrail(case_id=test_cases["wpa2_personal_2g"], + update_report.update_testrail(case_id=test_cases["wpa_wpa2_personal_mixed_2g"], status_id=1, msg='profile created successfully') assert setup_profiles['wpa2_personal_2g'] else: - update_report.update_testrail(case_id=test_cases["wpa2_personal_2g"], + update_report.update_testrail(case_id=test_cases["wpa_wpa2_personal_mixed_2g"], status_id=5, msg='Failed to create profile') assert False @@ -274,15 +274,15 @@ class TestVLANModeConnectivitySuiteTwo(object): @pytest.mark.wpa_wpa2_personal_mixed @pytest.mark.fiveg def test_setup_wpa_wpa2_personal_mixed_5g_ssid_profile(self, setup_profiles, update_report, - test_cases): + test_cases): if setup_profiles['wpa2_personal_5g']: - update_report.update_testrail(case_id=test_cases["wpa2_personal_5g"], + update_report.update_testrail(case_id=test_cases["wpa_wpa2_personal_mixed_5g"], status_id=1, msg='profile created successfully') assert setup_profiles['wpa2_personal_5g'] else: - update_report.update_testrail(case_id=test_cases["wpa2_personal_5g"], + update_report.update_testrail(case_id=test_cases["wpa_wpa2_personal_mixed_5g"], status_id=5, msg='Failed to create profile') assert False @@ -335,13 +335,11 @@ setup_params_enterprise = { "mode": "VLAN", "ssid_modes": { "wpa_enterprise": [ - {"ssid_name": "ssid_wpa_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}], + {"ssid_name": "ssid_wpa_eap_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_wpa_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], "wpa2_enterprise": [ - {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}], + {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], "wpa3_enterprise": [ {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, @@ -350,6 +348,7 @@ setup_params_enterprise = { "radius": True } + @pytest.mark.enterprise @allure.feature("VLAN MODE ENTERPRISE SETUP") @pytest.mark.parametrize( diff --git a/tests/e2e/basic/conftest.py b/tests/e2e/basic/conftest.py index 4ae800bdb..714c847d3 100644 --- a/tests/e2e/basic/conftest.py +++ b/tests/e2e/basic/conftest.py @@ -203,6 +203,34 @@ def setup_profiles(request, setup_controller, testbed, setup_vlan, get_equipment allure.attach(body=str(e), name="SSID Profile Creation Failed") + if mode == "wpa_wpa2_personal_mixed": + for j in profile_data["ssid"][mode]: + # print(j) + if mode in get_markers.keys() and get_markers[mode]: + try: + if "twog" in get_markers.keys() and get_markers["twog"] and "is2dot4GHz" in list( + j["appliedRadios"]): + creates_profile = instantiate_profile.create_wpa_wpa2_personal_mixed_ssid_profile(profile_data=j) + test_cases["wpa_wpa2_personal_mixed_2g"] = True + allure.attach(body=str(creates_profile), + name="SSID Profile Created") + except Exception as e: + print(e) + test_cases["wpa_wpa2_personal_mixed_2g"] = False + allure.attach(body=str(e), + name="SSID Profile Creation Failed") + try: + if "fiveg" in get_markers.keys() and get_markers["fiveg"] and "is5GHz" in list( + j["appliedRadios"]): + creates_profile = instantiate_profile.create_wpa_wpa2_personal_mixed_ssid_profile(profile_data=j) + test_cases["wpa_wpa2_personal_mixed_5g"] = True + allure.attach(body=str(creates_profile), + name="SSID Profile Created") + except Exception as e: + print(e) + test_cases["wpa_wpa2_personal_mixed_5g"] = False + allure.attach(body=str(e), + name="SSID Profile Creation Failed") if mode == "wpa3_personal": for j in profile_data["ssid"][mode]: print(j) @@ -238,7 +266,8 @@ def setup_profiles(request, setup_controller, testbed, setup_vlan, get_equipment try: if "twog" in get_markers.keys() and get_markers["twog"] and "is2dot4GHz" in list( j["appliedRadios"]): - creates_profile = instantiate_profile.create_wpa3_personal_mixed_ssid_profile(profile_data=j) + creates_profile = instantiate_profile.create_wpa3_personal_mixed_ssid_profile( + profile_data=j) test_cases["wpa3_personal_mixed_2g"] = True allure.attach(body=str(creates_profile), name="SSID Profile Created") @@ -250,7 +279,8 @@ def setup_profiles(request, setup_controller, testbed, setup_vlan, get_equipment try: if "fiveg" in get_markers.keys() and get_markers["fiveg"] and "is5GHz" in list( j["appliedRadios"]): - creates_profile = instantiate_profile.create_wpa3_personal_mixed_ssid_profile(profile_data=j) + creates_profile = instantiate_profile.create_wpa3_personal_mixed_ssid_profile( + profile_data=j) test_cases["wpa3_personal_mixed_5g"] = True allure.attach(body=str(creates_profile), name="SSID Profile Created") @@ -260,7 +290,6 @@ def setup_profiles(request, setup_controller, testbed, setup_vlan, get_equipment allure.attach(body=str(e), name="SSID Profile Creation Failed") - if mode == "wpa2_enterprise": for j in profile_data["ssid"][mode]: # print(j) diff --git a/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py b/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py index 74a7db1cd..514e6398f 100644 --- a/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py +++ b/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_security_modes.py @@ -20,7 +20,6 @@ setup_params_general = { } -@pytest.mark.basic @allure.feature("BRIDGE MODE CLIENT CONNECTIVITY") @pytest.mark.parametrize( 'setup_profiles', @@ -210,8 +209,8 @@ setup_params_general_two = { {"ssid_name": "ssid_wpa3_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], "security_key": "something"}], "wpa_wpa2_personal_mixed": [ - {"ssid_name": "ssid_wpa_wpa3_p_m_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa_wpa3_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + {"ssid_name": "ssid_wpa_wpa2_p_m_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_wpa2_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], "security_key": "something"}] }, "rf": {}, @@ -237,7 +236,7 @@ class TestBridgeModeConnectivitySuiteTwo(object): profile_data = setup_params_general_two["ssid_modes"]["wpa3_personal"][0] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] - security = ["wpa3"] + security = "wpa3" mode = "BRIDGE" band = "twog" vlan = 1 @@ -264,7 +263,7 @@ class TestBridgeModeConnectivitySuiteTwo(object): profile_data = setup_params_general_two["ssid_modes"]["wpa3_personal"][1] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] - security = ["wpa3"] + security = "wpa3" mode = "BRIDGE" band = "fiveg" vlan = 1 @@ -344,12 +343,13 @@ class TestBridgeModeConnectivitySuiteTwo(object): @pytest.mark.wpa_wpa2_personal_mixed @pytest.mark.twog @allure.story('wpa wpa2 personal mixed 2.4 GHZ Band') - def test_wpa_wpa2_personal_ssid_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, update_report, - test_cases): - profile_data = setup_params_general_two["ssid_modes"]["wpa_wpa3_personal_mixed"][0] + def test_wpa_wpa2_personal_ssid_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, + update_report, + test_cases): + profile_data = setup_params_general_two["ssid_modes"]["wpa_wpa2_personal_mixed"][0] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] - security = ["wpa3"] + security = "wpa2" mode = "BRIDGE" band = "twog" vlan = 1 @@ -372,11 +372,12 @@ class TestBridgeModeConnectivitySuiteTwo(object): @pytest.mark.wpa_wpa2_personal_mixed @pytest.mark.fiveg @allure.story('wpa wpa2 personal mixed 5 GHZ Band') - def test_wpa_wpa2_personal_ssid_5g(self, station_names_fiveg, get_lanforge_data, lf_test, test_cases, update_report): - profile_data = setup_params_general_two["ssid_modes"]["wpa_wpa3_personal_mixed"][1] + def test_wpa_wpa2_personal_ssid_5g(self, station_names_fiveg, get_lanforge_data, lf_test, test_cases, + update_report): + profile_data = setup_params_general_two["ssid_modes"]["wpa_wpa2_personal_mixed"][1] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] - security = ["wpa3"] + security = "wpa2" mode = "BRIDGE" band = "fiveg" vlan = 1 @@ -401,13 +402,11 @@ setup_params_enterprise = { "mode": "BRIDGE", "ssid_modes": { "wpa_enterprise": [ - {"ssid_name": "ssid_wpa_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}], + {"ssid_name": "ssid_wpa_eap_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_wpa_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], "wpa2_enterprise": [ - {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}], + {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], "wpa3_enterprise": [ {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, @@ -427,67 +426,67 @@ setup_params_enterprise = { @pytest.mark.usefixtures("setup_profiles") class TestBridgeModeEnterprise(object): - @pytest.mark.wpa_enterprise - @pytest.mark.twog - def test_wpa_enterprise_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, update_report, - test_cases, radius_info): - profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][0] - ssid_name = profile_data["ssid_name"] - security_key = profile_data["security_key"] - security = "wpa2" - mode = "BRIDGE" - band = "twog" - vlan = 1 - ttls_passwd = radius_info["password"] - eap = "TTLS" - identity = radius_info['user'] - passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, - passkey=security_key, mode=mode, band=band, - eap=eap, ttls_passwd=ttls_passwd, identity=identity, - station_name=station_names_twog, vlan_id=vlan) - - if passes: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], - status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( - passes)) - else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], - status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( - passes)) - assert passes - - @pytest.mark.wpa_enterprise - @pytest.mark.fiveg - def test_wpa_enterprise_5g(self, station_names_fiveg, setup_profiles, get_lanforge_data, lf_test, update_report, - test_cases, radius_info): - profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][1] - ssid_name = profile_data["ssid_name"] - security_key = profile_data["security_key"] - security = "wpa2" - mode = "BRIDGE" - band = "fiveg" - vlan = 1 - ttls_passwd = radius_info["password"] - eap = "TTLS" - identity = radius_info['user'] - passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, - passkey=security_key, mode=mode, band=band, - eap=eap, ttls_passwd=ttls_passwd, identity=identity, - station_name=station_names_fiveg, vlan_id=vlan) - - if passes: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], - status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( - passes)) - else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], - status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( - passes)) - assert passes + # @pytest.mark.wpa_enterprise + # @pytest.mark.twog + # def test_wpa_enterprise_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, update_report, + # test_cases, radius_info): + # profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][0] + # ssid_name = profile_data["ssid_name"] + # security_key = profile_data["security_key"] + # security = "wpa" + # mode = "BRIDGE" + # band = "twog" + # vlan = 1 + # ttls_passwd = radius_info["password"] + # eap = "TTLS" + # identity = radius_info['user'] + # passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, + # passkey=security_key, mode=mode, band=band, + # eap=eap, ttls_passwd=ttls_passwd, identity=identity, + # station_name=station_names_twog, vlan_id=vlan) + # + # if passes: + # update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + # status_id=1, + # msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + # passes)) + # else: + # update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + # status_id=5, + # msg='2G WPA Client Connectivity Failed - bridge mode' + str( + # passes)) + # assert passes + # + # @pytest.mark.wpa_enterprise + # @pytest.mark.fiveg + # def test_wpa_enterprise_5g(self, station_names_fiveg, setup_profiles, get_lanforge_data, lf_test, update_report, + # test_cases, radius_info): + # profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][1] + # ssid_name = profile_data["ssid_name"] + # security_key = profile_data["security_key"] + # security = "wpa" + # mode = "BRIDGE" + # band = "fiveg" + # vlan = 1 + # ttls_passwd = radius_info["password"] + # eap = "TTLS" + # identity = radius_info['user'] + # passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, + # passkey=security_key, mode=mode, band=band, + # eap=eap, ttls_passwd=ttls_passwd, identity=identity, + # station_name=station_names_fiveg, vlan_id=vlan) + # + # if passes: + # update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + # status_id=1, + # msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + # passes)) + # else: + # update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + # status_id=5, + # msg='2G WPA Client Connectivity Failed - bridge mode' + str( + # passes)) + # assert passes @pytest.mark.wpa2_enterprise @pytest.mark.twog @@ -495,7 +494,6 @@ class TestBridgeModeEnterprise(object): test_cases, radius_info): profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][0] ssid_name = profile_data["ssid_name"] - security_key = profile_data["security_key"] security = "wpa2" mode = "BRIDGE" band = "twog" @@ -504,7 +502,7 @@ class TestBridgeModeEnterprise(object): eap = "TTLS" identity = radius_info['user'] passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, - passkey=security_key, mode=mode, band=band, + mode=mode, band=band, eap=eap, ttls_passwd=ttls_passwd, identity=identity, station_name=station_names_twog, vlan_id=vlan) @@ -526,7 +524,6 @@ class TestBridgeModeEnterprise(object): test_cases, radius_info): profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][1] ssid_name = profile_data["ssid_name"] - security_key = profile_data["security_key"] security = "wpa2" mode = "BRIDGE" band = "fiveg" @@ -535,7 +532,7 @@ class TestBridgeModeEnterprise(object): eap = "TTLS" identity = radius_info['user'] passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, - passkey=security_key, mode=mode, band=band, + mode=mode, band=band, eap=eap, ttls_passwd=ttls_passwd, identity=identity, station_name=station_names_fiveg, vlan_id=vlan) @@ -557,8 +554,7 @@ class TestBridgeModeEnterprise(object): test_cases, radius_info): profile_data = setup_params_enterprise["ssid_modes"]["wpa3_enterprise"][0] ssid_name = profile_data["ssid_name"] - security_key = profile_data["security_key"] - security = "wpa2" + security = "wpa3" mode = "BRIDGE" band = "twog" vlan = 1 @@ -566,7 +562,7 @@ class TestBridgeModeEnterprise(object): eap = "TTLS" identity = radius_info['user'] passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, - passkey=security_key, mode=mode, band=band, + mode=mode, band=band, eap=eap, ttls_passwd=ttls_passwd, identity=identity, station_name=station_names_twog, vlan_id=vlan) @@ -588,8 +584,7 @@ class TestBridgeModeEnterprise(object): test_cases, radius_info): profile_data = setup_params_enterprise["ssid_modes"]["wpa3_enterprise"][1] ssid_name = profile_data["ssid_name"] - security_key = profile_data["security_key"] - security = "wpa2" + security = "wpa3" mode = "BRIDGE" band = "fiveg" vlan = 1 @@ -597,7 +592,7 @@ class TestBridgeModeEnterprise(object): eap = "TTLS" identity = radius_info['user'] passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, - passkey=security_key, mode=mode, band=band, + mode=mode, band=band, eap=eap, ttls_passwd=ttls_passwd, identity=identity, station_name=station_names_fiveg, vlan_id=vlan) diff --git a/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_security_modes.py b/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_security_modes.py index 0296a284a..550ce865c 100644 --- a/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_security_modes.py +++ b/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_security_modes.py @@ -1,7 +1,7 @@ -import pytest import allure +import pytest -pytestmark = [pytest.mark.client_connectivity, pytest.mark.nat, pytest.mark.sanity] +pytestmark = [pytest.mark.client_connectivity, pytest.mark.NAT, pytest.mark.sanity] setup_params_general = { "mode": "NAT", @@ -33,81 +33,73 @@ class TestNATModeConnectivitySuiteOne(object): @pytest.mark.open @pytest.mark.twog @allure.story('open 2.4 GHZ Band') - def test_open_ssid_2g(self, request, setup_profiles, get_lanforge_data, lf_test, update_report, test_cases): + def test_open_ssid_2g(self, setup_profiles, get_lanforge_data, lf_test, update_report, station_names_twog, + test_cases): profile_data = setup_params_general["ssid_modes"]["open"][0] ssid_name = profile_data["ssid_name"] security_key = "[BLANK]" security = "open" - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) mode = "NAT" band = "twog" vlan = 1 passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, passkey=security_key, mode=mode, band=band, - station_name=station_names, vlan_id=vlan) + station_name=station_names_twog, vlan_id=vlan) - if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], - status_id=1, - msg='2G WPA Client Connectivity Passed successfully - NAT mode' + str( - passes)) - else: - update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], - status_id=5, - msg='2G WPA Client Connectivity Failed - NAT mode' + str( - passes)) + # if result: + # update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], + # status_id=1, + # msg='2G WPA Client Connectivity Passed successfully - NAT mode' + str( + # passes)) + # else: + # update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], + # status_id=5, + # msg='2G WPA Client Connectivity Failed - NAT mode' + str( + # passes)) assert result @pytest.mark.open @pytest.mark.fiveg @allure.story('open 5 GHZ Band') - def test_open_ssid_5g(self, request, get_lanforge_data, lf_test, test_cases, update_report): + def test_open_ssid_5g(self, get_lanforge_data, lf_test, test_cases, station_names_fiveg, update_report): profile_data = setup_params_general["ssid_modes"]["open"][1] ssid_name = profile_data["ssid_name"] security_key = "[BLANK]" security = "open" - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) mode = "NAT" band = "fiveg" vlan = 1 passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, passkey=security_key, mode=mode, band=band, - station_name=station_names, vlan_id=vlan) + station_name=station_names_fiveg, vlan_id=vlan) - if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], - status_id=1, - msg='2G WPA Client Connectivity Passed successfully - NAT mode' + str( - passes)) - else: - update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], - status_id=5, - msg='2G WPA Client Connectivity Failed - NAT mode' + str( - passes)) + # if result: + # update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], + # status_id=1, + # msg='2G WPA Client Connectivity Passed successfully - NAT mode' + str( + # passes)) + # else: + # update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], + # status_id=5, + # msg='2G WPA Client Connectivity Failed - NAT mode' + str( + # passes)) assert result @pytest.mark.wpa @pytest.mark.twog @allure.story('wpa 2.4 GHZ Band') def test_wpa_ssid_2g(self, request, get_lanforge_data, update_report, - lf_test, test_cases): + lf_test, test_cases, station_names_twog): profile_data = setup_params_general["ssid_modes"]["wpa"][0] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] security = "wpa" - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) mode = "NAT" band = "twog" vlan = 1 passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, passkey=security_key, mode=mode, band=band, - station_name=station_names, vlan_id=vlan) + station_name=station_names_twog, vlan_id=vlan) if result: update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], @@ -124,90 +116,83 @@ class TestNATModeConnectivitySuiteOne(object): @pytest.mark.wpa @pytest.mark.fiveg @allure.story('wpa 5 GHZ Band') - def test_wpa_ssid_5g(self, request, lf_test, update_report, test_cases, get_lanforge_data): + def test_wpa_ssid_5g(self, lf_test, update_report, test_cases, station_names_fiveg, get_lanforge_data): profile_data = setup_params_general["ssid_modes"]["wpa"][1] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] security = "wpa" - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) mode = "NAT" band = "fiveg" vlan = 1 passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, passkey=security_key, mode=mode, band=band, - station_name=station_names, vlan_id=vlan) + station_name=station_names_fiveg, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], + update_report.update_testrail(case_id=test_cases["5g_wpa_NAT"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - NAT mode' + str( + msg='5G WPA Client Connectivity Passed successfully - NAT mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], + update_report.update_testrail(case_id=test_cases["5g_wpa_NAT"], status_id=5, - msg='2G WPA Client Connectivity Failed - NAT mode' + str( + msg='5G WPA Client Connectivity Failed - NAT mode' + str( passes)) assert result @pytest.mark.wpa2_personal @pytest.mark.twog @allure.story('wpa2_personal 2.4 GHZ Band') - def test_wpa2_personal_ssid_2g(self, request, get_lanforge_data, lf_test, update_report, test_cases): + def test_wpa2_personal_ssid_2g(self, get_lanforge_data, lf_test, update_report, test_cases, + station_names_twog): profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][0] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] security = "wpa2" - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) mode = "NAT" band = "twog" vlan = 1 passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, passkey=security_key, mode=mode, band=band, - station_name=station_names, vlan_id=vlan) + station_name=station_names_twog, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], + update_report.update_testrail(case_id=test_cases["2g_wpa2_NAT"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - NAT mode' + str( + msg='2G WPA2 Client Connectivity Passed successfully - NAT mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], + update_report.update_testrail(case_id=test_cases["2g_wpa2_NAT"], status_id=5, - msg='2G WPA Client Connectivity Failed - NAT mode' + str( + msg='2G WPA2 Client Connectivity Failed - NAT mode' + str( passes)) assert result @pytest.mark.wpa2_personal @pytest.mark.fiveg @allure.story('wpa2_personal 5 GHZ Band') - def test_wpa2_personal_ssid_5g(self, request, get_lanforge_data, update_report, test_cases, lf_test): + def test_wpa2_personal_ssid_5g(self, get_lanforge_data, update_report, test_cases, station_names_fiveg, + lf_test): profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][1] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] security = "wpa2" - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) mode = "NAT" band = "fiveg" vlan = 1 passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, passkey=security_key, mode=mode, band=band, - station_name=station_names, vlan_id=vlan) + station_name=station_names_fiveg, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], + update_report.update_testrail(case_id=test_cases["5g_wpa2_NAT"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - NAT mode' + str( + msg='5G WPA2 Client Connectivity Passed successfully - NAT mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], + update_report.update_testrail(case_id=test_cases["5g_wpa2_NAT"], status_id=5, - msg='2G WPA Client Connectivity Failed - NAT mode' + str( + msg='5G WPA2 Client Connectivity Failed - NAT mode' + str( passes)) assert result @@ -224,8 +209,8 @@ setup_params_general_two = { {"ssid_name": "ssid_wpa3_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], "security_key": "something"}], "wpa_wpa2_personal_mixed": [ - {"ssid_name": "ssid_wpa_wpa3_p_m_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa_wpa3_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + {"ssid_name": "ssid_wpa_wpa2_p_m_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_wpa2_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], "security_key": "something"}] }, "rf": {}, @@ -233,7 +218,6 @@ setup_params_general_two = { } -@pytest.mark.shivam @allure.feature("NAT MODE CLIENT CONNECTIVITY") @pytest.mark.parametrize( 'setup_profiles', @@ -247,21 +231,18 @@ class TestNATModeConnectivitySuiteTwo(object): @pytest.mark.wpa3_personal @pytest.mark.twog @allure.story('open 2.4 GHZ Band') - def test_wpa3_personal_ssid_2g(self, request, setup_profiles, get_lanforge_data, lf_test, update_report, + def test_wpa3_personal_ssid_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, update_report, test_cases): profile_data = setup_params_general_two["ssid_modes"]["wpa3_personal"][0] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] - security = ["wpa3"] - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) + security = "wpa3" mode = "NAT" band = "twog" vlan = 1 passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, passkey=security_key, mode=mode, band=band, - station_name=station_names, vlan_id=vlan) + station_name=station_names_twog, vlan_id=vlan) if result: update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], @@ -278,20 +259,17 @@ class TestNATModeConnectivitySuiteTwo(object): @pytest.mark.wpa3_personal @pytest.mark.fiveg @allure.story('open 5 GHZ Band') - def test_wpa3_personal_ssid_5g(self, request, get_lanforge_data, lf_test, test_cases, update_report): + def test_wpa3_personal_ssid_5g(self, station_names_fiveg, get_lanforge_data, lf_test, test_cases, update_report): profile_data = setup_params_general_two["ssid_modes"]["wpa3_personal"][1] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] - security = ["wpa3"] - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) + security = "wpa3" mode = "NAT" band = "fiveg" vlan = 1 passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, passkey=security_key, mode=mode, band=band, - station_name=station_names, vlan_id=vlan) + station_name=station_names_fiveg, vlan_id=vlan) if result: update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], @@ -308,21 +286,19 @@ class TestNATModeConnectivitySuiteTwo(object): @pytest.mark.wpa3_personal_mixed @pytest.mark.twog @allure.story('open 2.4 GHZ Band') - def test_wpa3_personal_mixed_ssid_2g(self, request, setup_profiles, get_lanforge_data, lf_test, update_report, + def test_wpa3_personal_mixed_ssid_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, + update_report, test_cases): profile_data = setup_params_general_two["ssid_modes"]["wpa3_personal_mixed"][0] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] security = "wpa3" - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) mode = "NAT" band = "twog" vlan = 1 passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, passkey=security_key, mode=mode, band=band, - station_name=station_names, vlan_id=vlan) + station_name=station_names_twog, vlan_id=vlan) if result: update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], @@ -339,20 +315,18 @@ class TestNATModeConnectivitySuiteTwo(object): @pytest.mark.wpa3_personal_mixed @pytest.mark.fiveg @allure.story('open 5 GHZ Band') - def test_wpa3_personal_mixed_ssid_5g(self, request, get_lanforge_data, lf_test, test_cases, update_report): + def test_wpa3_personal_mixed_ssid_5g(self, station_names_fiveg, get_lanforge_data, lf_test, test_cases, + update_report): profile_data = setup_params_general_two["ssid_modes"]["wpa3_personal_mixed"][1] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] security = "wpa3" - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) mode = "NAT" band = "fiveg" vlan = 1 passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, passkey=security_key, mode=mode, band=band, - station_name=station_names, vlan_id=vlan) + station_name=station_names_fiveg, vlan_id=vlan) if result: update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], @@ -369,13 +343,14 @@ class TestNATModeConnectivitySuiteTwo(object): @pytest.mark.wpa_wpa2_personal_mixed @pytest.mark.twog @allure.story('wpa wpa2 personal mixed 2.4 GHZ Band') - def test_wpa_wpa2_personal_ssid_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, update_report, - test_cases): - profile_data = setup_params_general_two["ssid_modes"]["wpa_wpa3_personal_mixed"][0] + def test_wpa_wpa2_personal_ssid_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, + update_report, + test_cases): + profile_data = setup_params_general_two["ssid_modes"]["wpa_wpa2_personal_mixed"][0] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] - security = ["wpa3"] - mode = "BRIDGE" + security = "wpa2" + mode = "NAT" band = "twog" vlan = 1 passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, @@ -383,26 +358,27 @@ class TestNATModeConnectivitySuiteTwo(object): station_name=station_names_twog, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + msg='2G WPA Client Connectivity Passed successfully - NAT mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( + msg='2G WPA Client Connectivity Failed - NAT mode' + str( passes)) assert result @pytest.mark.wpa_wpa2_personal_mixed @pytest.mark.fiveg @allure.story('wpa wpa2 personal mixed 5 GHZ Band') - def test_wpa_wpa2_personal_ssid_5g(self, station_names_fiveg, get_lanforge_data, lf_test, test_cases, update_report): - profile_data = setup_params_general_two["ssid_modes"]["wpa_wpa3_personal_mixed"][1] + def test_wpa_wpa2_personal_ssid_5g(self, station_names_fiveg, get_lanforge_data, lf_test, test_cases, + update_report): + profile_data = setup_params_general_two["ssid_modes"]["wpa_wpa2_personal_mixed"][1] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] - security = ["wpa3"] - mode = "BRIDGE" + security = "wpa2" + mode = "NAT" band = "fiveg" vlan = 1 passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, @@ -410,14 +386,14 @@ class TestNATModeConnectivitySuiteTwo(object): station_name=station_names_fiveg, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + msg='2G WPA Client Connectivity Passed successfully - NAT mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( + msg='2G WPA Client Connectivity Failed - NAT mode' + str( passes)) assert result @@ -426,13 +402,11 @@ setup_params_enterprise = { "mode": "NAT", "ssid_modes": { "wpa_enterprise": [ - {"ssid_name": "ssid_wpa_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}], + {"ssid_name": "ssid_wpa_eap_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_wpa_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], "wpa2_enterprise": [ - {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}], + {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], "wpa3_enterprise": [ {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, @@ -452,67 +426,67 @@ setup_params_enterprise = { @pytest.mark.usefixtures("setup_profiles") class TestNATModeEnterprise(object): - @pytest.mark.wpa_enterprise - @pytest.mark.twog - def test_wpa_enterprise_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, update_report, - test_cases, radius_info): - profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][0] - ssid_name = profile_data["ssid_name"] - security_key = profile_data["security_key"] - security = "wpa2" - mode = "BRIDGE" - band = "twog" - vlan = 1 - ttls_passwd = radius_info["password"] - eap = "TTLS" - identity = radius_info['user'] - passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, - passkey=security_key, mode=mode, band=band, - eap=eap, ttls_passwd=ttls_passwd, identity=identity, - station_name=station_names_twog, vlan_id=vlan) - - if passes: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], - status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( - passes)) - else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], - status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( - passes)) - assert passes - - @pytest.mark.wpa_enterprise - @pytest.mark.fiveg - def test_wpa_enterprise_5g(self, station_names_fiveg, setup_profiles, get_lanforge_data, lf_test, update_report, - test_cases, radius_info): - profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][1] - ssid_name = profile_data["ssid_name"] - security_key = profile_data["security_key"] - security = "wpa2" - mode = "BRIDGE" - band = "fiveg" - vlan = 1 - ttls_passwd = radius_info["password"] - eap = "TTLS" - identity = radius_info['user'] - passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, - passkey=security_key, mode=mode, band=band, - eap=eap, ttls_passwd=ttls_passwd, identity=identity, - station_name=station_names_fiveg, vlan_id=vlan) - - if passes: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], - status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( - passes)) - else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], - status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( - passes)) - assert passes + # @pytest.mark.wpa_enterprise + # @pytest.mark.twog + # def test_wpa_enterprise_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, update_report, + # test_cases, radius_info): + # profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][0] + # ssid_name = profile_data["ssid_name"] + # security_key = profile_data["security_key"] + # security = "wpa" + # mode = "NAT" + # band = "twog" + # vlan = 1 + # ttls_passwd = radius_info["password"] + # eap = "TTLS" + # identity = radius_info['user'] + # passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, + # passkey=security_key, mode=mode, band=band, + # eap=eap, ttls_passwd=ttls_passwd, identity=identity, + # station_name=station_names_twog, vlan_id=vlan) + # + # if passes: + # update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], + # status_id=1, + # msg='2G WPA Client Connectivity Passed successfully - NAT mode' + str( + # passes)) + # else: + # update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], + # status_id=5, + # msg='2G WPA Client Connectivity Failed - NAT mode' + str( + # passes)) + # assert passes + # + # @pytest.mark.wpa_enterprise + # @pytest.mark.fiveg + # def test_wpa_enterprise_5g(self, station_names_fiveg, setup_profiles, get_lanforge_data, lf_test, update_report, + # test_cases, radius_info): + # profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][1] + # ssid_name = profile_data["ssid_name"] + # security_key = profile_data["security_key"] + # security = "wpa" + # mode = "NAT" + # band = "fiveg" + # vlan = 1 + # ttls_passwd = radius_info["password"] + # eap = "TTLS" + # identity = radius_info['user'] + # passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, + # passkey=security_key, mode=mode, band=band, + # eap=eap, ttls_passwd=ttls_passwd, identity=identity, + # station_name=station_names_fiveg, vlan_id=vlan) + # + # if passes: + # update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], + # status_id=1, + # msg='2G WPA Client Connectivity Passed successfully - NAT mode' + str( + # passes)) + # else: + # update_report.update_testrail(case_id=test_cases["2g_wpa_NAT"], + # status_id=5, + # msg='2G WPA Client Connectivity Failed - NAT mode' + str( + # passes)) + # assert passes @pytest.mark.wpa2_enterprise @pytest.mark.twog @@ -520,7 +494,6 @@ class TestNATModeEnterprise(object): test_cases, radius_info): profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][0] ssid_name = profile_data["ssid_name"] - security_key = profile_data["security_key"] security = "wpa2" mode = "NAT" band = "twog" @@ -529,7 +502,7 @@ class TestNATModeEnterprise(object): eap = "TTLS" identity = radius_info['user'] passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, - passkey=security_key, mode=mode, band=band, + mode=mode, band=band, eap=eap, ttls_passwd=ttls_passwd, identity=identity, station_name=station_names_twog, vlan_id=vlan) @@ -551,7 +524,6 @@ class TestNATModeEnterprise(object): test_cases, radius_info): profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][1] ssid_name = profile_data["ssid_name"] - security_key = profile_data["security_key"] security = "wpa2" mode = "NAT" band = "fiveg" @@ -560,7 +532,7 @@ class TestNATModeEnterprise(object): eap = "TTLS" identity = radius_info['user'] passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, - passkey=security_key, mode=mode, band=band, + mode=mode, band=band, eap=eap, ttls_passwd=ttls_passwd, identity=identity, station_name=station_names_fiveg, vlan_id=vlan) @@ -582,8 +554,7 @@ class TestNATModeEnterprise(object): test_cases, radius_info): profile_data = setup_params_enterprise["ssid_modes"]["wpa3_enterprise"][0] ssid_name = profile_data["ssid_name"] - security_key = profile_data["security_key"] - security = "wpa2" + security = "wpa3" mode = "NAT" band = "twog" vlan = 1 @@ -591,7 +562,7 @@ class TestNATModeEnterprise(object): eap = "TTLS" identity = radius_info['user'] passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, - passkey=security_key, mode=mode, band=band, + mode=mode, band=band, eap=eap, ttls_passwd=ttls_passwd, identity=identity, station_name=station_names_twog, vlan_id=vlan) @@ -613,8 +584,7 @@ class TestNATModeEnterprise(object): test_cases, radius_info): profile_data = setup_params_enterprise["ssid_modes"]["wpa3_enterprise"][1] ssid_name = profile_data["ssid_name"] - security_key = profile_data["security_key"] - security = "wpa2" + security = "wpa3" mode = "NAT" band = "fiveg" vlan = 1 @@ -622,7 +592,7 @@ class TestNATModeEnterprise(object): eap = "TTLS" identity = radius_info['user'] passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, - passkey=security_key, mode=mode, band=band, + mode=mode, band=band, eap=eap, ttls_passwd=ttls_passwd, identity=identity, station_name=station_names_fiveg, vlan_id=vlan) diff --git a/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_security_modes.py b/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_security_modes.py index 9b885dc79..4be86468b 100644 --- a/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_security_modes.py +++ b/tests/e2e/basic/validation_of_operating_modes/vlan_mode/client_connectivity/test_security_modes.py @@ -1,7 +1,7 @@ -import pytest import allure +import pytest -pytestmark = [pytest.mark.client_connectivity, pytest.mark.vlan, pytest.mark.sanity] +pytestmark = [pytest.mark.client_connectivity, pytest.mark.VLAN, pytest.mark.sanity] setup_params_general = { "mode": "VLAN", @@ -28,86 +28,78 @@ setup_params_general = { scope="class" ) @pytest.mark.usefixtures("setup_profiles") -class TestVLANModeConnectivity(object): +class TestVLANModeConnectivitySuiteOne(object): @pytest.mark.open @pytest.mark.twog @allure.story('open 2.4 GHZ Band') - def test_open_ssid_2g(self, setup_profiles, request, get_lanforge_data, lf_test, update_report, test_cases): + def test_open_ssid_2g(self, setup_profiles, get_lanforge_data, lf_test, update_report, station_names_twog, + test_cases): profile_data = setup_params_general["ssid_modes"]["open"][0] ssid_name = profile_data["ssid_name"] security_key = "[BLANK]" security = "open" - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) mode = "VLAN" band = "twog" - vlan = 100 + vlan = 1 passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, passkey=security_key, mode=mode, band=band, - station_name=station_names, vlan_id=vlan) + station_name=station_names_twog, vlan_id=vlan) - if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], - status_id=1, - msg='2G WPA Client Connectivity Passed successfully - VLAN mode' + str( - passes)) - else: - update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], - status_id=5, - msg='2G WPA Client Connectivity Failed - VLAN mode' + str( - passes)) + # if result: + # update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], + # status_id=1, + # msg='2G WPA Client Connectivity Passed successfully - VLAN mode' + str( + # passes)) + # else: + # update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], + # status_id=5, + # msg='2G WPA Client Connectivity Failed - VLAN mode' + str( + # passes)) assert result @pytest.mark.open @pytest.mark.fiveg @allure.story('open 5 GHZ Band') - def test_open_ssid_5g(self, request, get_lanforge_data, lf_test, test_cases, update_report): + def test_open_ssid_5g(self, get_lanforge_data, lf_test, test_cases, station_names_fiveg, update_report): profile_data = setup_params_general["ssid_modes"]["open"][1] ssid_name = profile_data["ssid_name"] security_key = "[BLANK]" security = "open" - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) mode = "VLAN" band = "fiveg" - vlan = 100 + vlan = 1 passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, passkey=security_key, mode=mode, band=band, - station_name=station_names, vlan_id=vlan) + station_name=station_names_fiveg, vlan_id=vlan) - if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], - status_id=1, - msg='2G WPA Client Connectivity Passed successfully - VLAN mode' + str( - passes)) - else: - update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], - status_id=5, - msg='2G WPA Client Connectivity Failed - VLAN mode' + str( - passes)) + # if result: + # update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], + # status_id=1, + # msg='2G WPA Client Connectivity Passed successfully - VLAN mode' + str( + # passes)) + # else: + # update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], + # status_id=5, + # msg='2G WPA Client Connectivity Failed - VLAN mode' + str( + # passes)) assert result @pytest.mark.wpa @pytest.mark.twog @allure.story('wpa 2.4 GHZ Band') def test_wpa_ssid_2g(self, request, get_lanforge_data, update_report, - lf_test, test_cases): + lf_test, test_cases, station_names_twog): profile_data = setup_params_general["ssid_modes"]["wpa"][0] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] security = "wpa" - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) mode = "VLAN" band = "twog" - vlan = 100 + vlan = 1 passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, passkey=security_key, mode=mode, band=band, - station_name=station_names, vlan_id=vlan) + station_name=station_names_twog, vlan_id=vlan) if result: update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], @@ -124,90 +116,83 @@ class TestVLANModeConnectivity(object): @pytest.mark.wpa @pytest.mark.fiveg @allure.story('wpa 5 GHZ Band') - def test_wpa_ssid_5g(self, request, lf_test, update_report, test_cases, get_lanforge_data): + def test_wpa_ssid_5g(self, lf_test, update_report, test_cases, station_names_fiveg, get_lanforge_data): profile_data = setup_params_general["ssid_modes"]["wpa"][1] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] security = "wpa" - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) mode = "VLAN" band = "fiveg" - vlan = 100 + vlan = 1 passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, passkey=security_key, mode=mode, band=band, - station_name=station_names, vlan_id=vlan) + station_name=station_names_fiveg, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], + update_report.update_testrail(case_id=test_cases["5g_wpa_VLAN"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - VLAN mode' + str( + msg='5G WPA Client Connectivity Passed successfully - VLAN mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], + update_report.update_testrail(case_id=test_cases["5g_wpa_VLAN"], status_id=5, - msg='2G WPA Client Connectivity Failed - VLAN mode' + str( + msg='5G WPA Client Connectivity Failed - VLAN mode' + str( passes)) assert result @pytest.mark.wpa2_personal @pytest.mark.twog @allure.story('wpa2_personal 2.4 GHZ Band') - def test_wpa2_personal_ssid_2g(self, request, get_lanforge_data, lf_test, update_report, test_cases): + def test_wpa2_personal_ssid_2g(self, get_lanforge_data, lf_test, update_report, test_cases, + station_names_twog): profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][0] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] security = "wpa2" - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_2dot4g_prefix"] + "0" + str(i)) mode = "VLAN" band = "twog" - vlan = 100 + vlan = 1 passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, passkey=security_key, mode=mode, band=band, - station_name=station_names, vlan_id=vlan) + station_name=station_names_twog, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], + update_report.update_testrail(case_id=test_cases["2g_wpa2_VLAN"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - VLAN mode' + str( + msg='2G WPA2 Client Connectivity Passed successfully - VLAN mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], + update_report.update_testrail(case_id=test_cases["2g_wpa2_VLAN"], status_id=5, - msg='2G WPA Client Connectivity Failed - VLAN mode' + str( + msg='2G WPA2 Client Connectivity Failed - VLAN mode' + str( passes)) assert result @pytest.mark.wpa2_personal @pytest.mark.fiveg @allure.story('wpa2_personal 5 GHZ Band') - def test_wpa2_personal_ssid_5g(self, request, get_lanforge_data, update_report, test_cases, lf_test): + def test_wpa2_personal_ssid_5g(self, get_lanforge_data, update_report, test_cases, station_names_fiveg, + lf_test): profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][1] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] security = "wpa2" - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) mode = "VLAN" band = "fiveg" - vlan = 100 + vlan = 1 passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, passkey=security_key, mode=mode, band=band, - station_name=station_names, vlan_id=vlan) + station_name=station_names_fiveg, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], + update_report.update_testrail(case_id=test_cases["5g_wpa2_VLAN"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - VLAN mode' + str( + msg='5G WPA2 Client Connectivity Passed successfully - VLAN mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], + update_report.update_testrail(case_id=test_cases["5g_wpa2_VLAN"], status_id=5, - msg='2G WPA Client Connectivity Failed - VLAN mode' + str( + msg='5G WPA2 Client Connectivity Failed - VLAN mode' + str( passes)) assert result @@ -224,8 +209,8 @@ setup_params_general_two = { {"ssid_name": "ssid_wpa3_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], "security_key": "something"}], "wpa_wpa2_personal_mixed": [ - {"ssid_name": "ssid_wpa_wpa3_p_m_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa_wpa3_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], + {"ssid_name": "ssid_wpa_wpa2_p_m_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, + {"ssid_name": "ssid_wpa_wpa2_p_m_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], "security_key": "something"}] }, "rf": {}, @@ -233,7 +218,6 @@ setup_params_general_two = { } -@pytest.mark.shivam @allure.feature("VLAN MODE CLIENT CONNECTIVITY") @pytest.mark.parametrize( 'setup_profiles', @@ -252,7 +236,7 @@ class TestVLANModeConnectivitySuiteTwo(object): profile_data = setup_params_general_two["ssid_modes"]["wpa3_personal"][0] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] - security = ["wpa3"] + security = "wpa3" mode = "VLAN" band = "twog" vlan = 1 @@ -275,20 +259,17 @@ class TestVLANModeConnectivitySuiteTwo(object): @pytest.mark.wpa3_personal @pytest.mark.fiveg @allure.story('open 5 GHZ Band') - def test_wpa3_personal_ssid_5g(self, request, get_lanforge_data, lf_test, test_cases, update_report): + def test_wpa3_personal_ssid_5g(self, station_names_fiveg, get_lanforge_data, lf_test, test_cases, update_report): profile_data = setup_params_general_two["ssid_modes"]["wpa3_personal"][1] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] - security = ["wpa3"] - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) + security = "wpa3" mode = "VLAN" band = "fiveg" vlan = 1 passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, passkey=security_key, mode=mode, band=band, - station_name=station_names, vlan_id=vlan) + station_name=station_names_fiveg, vlan_id=vlan) if result: update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], @@ -334,20 +315,18 @@ class TestVLANModeConnectivitySuiteTwo(object): @pytest.mark.wpa3_personal_mixed @pytest.mark.fiveg @allure.story('open 5 GHZ Band') - def test_wpa3_personal_mixed_ssid_5g(self, request, get_lanforge_data, lf_test, test_cases, update_report): + def test_wpa3_personal_mixed_ssid_5g(self, station_names_fiveg, get_lanforge_data, lf_test, test_cases, + update_report): profile_data = setup_params_general_two["ssid_modes"]["wpa3_personal_mixed"][1] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] security = "wpa3" - station_names = [] - for i in range(0, int(request.config.getini("num_stations"))): - station_names.append(get_lanforge_data["lanforge_5g_prefix"] + "0" + str(i)) mode = "VLAN" band = "fiveg" vlan = 1 passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, passkey=security_key, mode=mode, band=band, - station_name=station_names, vlan_id=vlan) + station_name=station_names_fiveg, vlan_id=vlan) if result: update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], @@ -364,13 +343,14 @@ class TestVLANModeConnectivitySuiteTwo(object): @pytest.mark.wpa_wpa2_personal_mixed @pytest.mark.twog @allure.story('wpa wpa2 personal mixed 2.4 GHZ Band') - def test_wpa_wpa2_personal_ssid_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, update_report, - test_cases): - profile_data = setup_params_general_two["ssid_modes"]["wpa_wpa3_personal_mixed"][0] + def test_wpa_wpa2_personal_ssid_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, + update_report, + test_cases): + profile_data = setup_params_general_two["ssid_modes"]["wpa_wpa2_personal_mixed"][0] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] - security = ["wpa3"] - mode = "BRIDGE" + security = "wpa2" + mode = "VLAN" band = "twog" vlan = 1 passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, @@ -378,26 +358,27 @@ class TestVLANModeConnectivitySuiteTwo(object): station_name=station_names_twog, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + msg='2G WPA Client Connectivity Passed successfully - VLAN mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( + msg='2G WPA Client Connectivity Failed - VLAN mode' + str( passes)) assert result @pytest.mark.wpa_wpa2_personal_mixed @pytest.mark.fiveg @allure.story('wpa wpa2 personal mixed 5 GHZ Band') - def test_wpa_wpa2_personal_ssid_5g(self, station_names_fiveg, get_lanforge_data, lf_test, test_cases, update_report): - profile_data = setup_params_general_two["ssid_modes"]["wpa_wpa3_personal_mixed"][1] + def test_wpa_wpa2_personal_ssid_5g(self, station_names_fiveg, get_lanforge_data, lf_test, test_cases, + update_report): + profile_data = setup_params_general_two["ssid_modes"]["wpa_wpa2_personal_mixed"][1] ssid_name = profile_data["ssid_name"] security_key = profile_data["security_key"] - security = ["wpa3"] - mode = "BRIDGE" + security = "wpa2" + mode = "VLAN" band = "fiveg" vlan = 1 passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security, @@ -405,14 +386,14 @@ class TestVLANModeConnectivitySuiteTwo(object): station_name=station_names_fiveg, vlan_id=vlan) if result: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( + msg='2G WPA Client Connectivity Passed successfully - VLAN mode' + str( passes)) else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], + update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( + msg='2G WPA Client Connectivity Failed - VLAN mode' + str( passes)) assert result @@ -421,13 +402,11 @@ setup_params_enterprise = { "mode": "VLAN", "ssid_modes": { "wpa_enterprise": [ - {"ssid_name": "ssid_wpa_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}], + {"ssid_name": "ssid_wpa_eap_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_wpa_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], "wpa2_enterprise": [ - {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"}, - {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"], - "security_key": "something"}], + {"ssid_name": "ssid_wpa2_eap_2g", "appliedRadios": ["is2dot4GHz"]}, + {"ssid_name": "ssid_wpa2_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}], "wpa3_enterprise": [ {"ssid_name": "ssid_wpa3_eap_2g", "appliedRadios": ["is2dot4GHz"]}, {"ssid_name": "ssid_wpa3_eap_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}]}, @@ -447,67 +426,67 @@ setup_params_enterprise = { @pytest.mark.usefixtures("setup_profiles") class TestVLANModeEnterprise(object): - @pytest.mark.wpa_enterprise - @pytest.mark.twog - def test_wpa_enterprise_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, update_report, - test_cases, radius_info): - profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][0] - ssid_name = profile_data["ssid_name"] - security_key = profile_data["security_key"] - security = "wpa2" - mode = "BRIDGE" - band = "twog" - vlan = 1 - ttls_passwd = radius_info["password"] - eap = "TTLS" - identity = radius_info['user'] - passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, - passkey=security_key, mode=mode, band=band, - eap=eap, ttls_passwd=ttls_passwd, identity=identity, - station_name=station_names_twog, vlan_id=vlan) - - if passes: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], - status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( - passes)) - else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], - status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( - passes)) - assert passes - - @pytest.mark.wpa_enterprise - @pytest.mark.fiveg - def test_wpa_enterprise_5g(self, station_names_fiveg, setup_profiles, get_lanforge_data, lf_test, update_report, - test_cases, radius_info): - profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][1] - ssid_name = profile_data["ssid_name"] - security_key = profile_data["security_key"] - security = "wpa2" - mode = "BRIDGE" - band = "fiveg" - vlan = 1 - ttls_passwd = radius_info["password"] - eap = "TTLS" - identity = radius_info['user'] - passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, - passkey=security_key, mode=mode, band=band, - eap=eap, ttls_passwd=ttls_passwd, identity=identity, - station_name=station_names_fiveg, vlan_id=vlan) - - if passes: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], - status_id=1, - msg='2G WPA Client Connectivity Passed successfully - bridge mode' + str( - passes)) - else: - update_report.update_testrail(case_id=test_cases["2g_wpa_bridge"], - status_id=5, - msg='2G WPA Client Connectivity Failed - bridge mode' + str( - passes)) - assert passes + # @pytest.mark.wpa_enterprise + # @pytest.mark.twog + # def test_wpa_enterprise_2g(self, station_names_twog, setup_profiles, get_lanforge_data, lf_test, update_report, + # test_cases, radius_info): + # profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][0] + # ssid_name = profile_data["ssid_name"] + # security_key = profile_data["security_key"] + # security = "wpa" + # mode = "VLAN" + # band = "twog" + # vlan = 1 + # ttls_passwd = radius_info["password"] + # eap = "TTLS" + # identity = radius_info['user'] + # passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, + # passkey=security_key, mode=mode, band=band, + # eap=eap, ttls_passwd=ttls_passwd, identity=identity, + # station_name=station_names_twog, vlan_id=vlan) + # + # if passes: + # update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], + # status_id=1, + # msg='2G WPA Client Connectivity Passed successfully - VLAN mode' + str( + # passes)) + # else: + # update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], + # status_id=5, + # msg='2G WPA Client Connectivity Failed - VLAN mode' + str( + # passes)) + # assert passes + # + # @pytest.mark.wpa_enterprise + # @pytest.mark.fiveg + # def test_wpa_enterprise_5g(self, station_names_fiveg, setup_profiles, get_lanforge_data, lf_test, update_report, + # test_cases, radius_info): + # profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][1] + # ssid_name = profile_data["ssid_name"] + # security_key = profile_data["security_key"] + # security = "wpa" + # mode = "VLAN" + # band = "fiveg" + # vlan = 1 + # ttls_passwd = radius_info["password"] + # eap = "TTLS" + # identity = radius_info['user'] + # passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, + # passkey=security_key, mode=mode, band=band, + # eap=eap, ttls_passwd=ttls_passwd, identity=identity, + # station_name=station_names_fiveg, vlan_id=vlan) + # + # if passes: + # update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], + # status_id=1, + # msg='2G WPA Client Connectivity Passed successfully - VLAN mode' + str( + # passes)) + # else: + # update_report.update_testrail(case_id=test_cases["2g_wpa_VLAN"], + # status_id=5, + # msg='2G WPA Client Connectivity Failed - VLAN mode' + str( + # passes)) + # assert passes @pytest.mark.wpa2_enterprise @pytest.mark.twog @@ -515,7 +494,6 @@ class TestVLANModeEnterprise(object): test_cases, radius_info): profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][0] ssid_name = profile_data["ssid_name"] - security_key = profile_data["security_key"] security = "wpa2" mode = "VLAN" band = "twog" @@ -524,7 +502,7 @@ class TestVLANModeEnterprise(object): eap = "TTLS" identity = radius_info['user'] passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, - passkey=security_key, mode=mode, band=band, + mode=mode, band=band, eap=eap, ttls_passwd=ttls_passwd, identity=identity, station_name=station_names_twog, vlan_id=vlan) @@ -546,7 +524,6 @@ class TestVLANModeEnterprise(object): test_cases, radius_info): profile_data = setup_params_enterprise["ssid_modes"]["wpa2_enterprise"][1] ssid_name = profile_data["ssid_name"] - security_key = profile_data["security_key"] security = "wpa2" mode = "VLAN" band = "fiveg" @@ -555,7 +532,7 @@ class TestVLANModeEnterprise(object): eap = "TTLS" identity = radius_info['user'] passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, - passkey=security_key, mode=mode, band=band, + mode=mode, band=band, eap=eap, ttls_passwd=ttls_passwd, identity=identity, station_name=station_names_fiveg, vlan_id=vlan) @@ -577,8 +554,7 @@ class TestVLANModeEnterprise(object): test_cases, radius_info): profile_data = setup_params_enterprise["ssid_modes"]["wpa3_enterprise"][0] ssid_name = profile_data["ssid_name"] - security_key = profile_data["security_key"] - security = "wpa2" + security = "wpa3" mode = "VLAN" band = "twog" vlan = 1 @@ -586,7 +562,7 @@ class TestVLANModeEnterprise(object): eap = "TTLS" identity = radius_info['user'] passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, - passkey=security_key, mode=mode, band=band, + mode=mode, band=band, eap=eap, ttls_passwd=ttls_passwd, identity=identity, station_name=station_names_twog, vlan_id=vlan) @@ -608,8 +584,7 @@ class TestVLANModeEnterprise(object): test_cases, radius_info): profile_data = setup_params_enterprise["ssid_modes"]["wpa3_enterprise"][1] ssid_name = profile_data["ssid_name"] - security_key = profile_data["security_key"] - security = "wpa2" + security = "wpa3" mode = "VLAN" band = "fiveg" vlan = 1 @@ -617,7 +592,7 @@ class TestVLANModeEnterprise(object): eap = "TTLS" identity = radius_info['user'] passes = lf_test.EAP_Connect(ssid=ssid_name, security=security, - passkey=security_key, mode=mode, band=band, + mode=mode, band=band, eap=eap, ttls_passwd=ttls_passwd, identity=identity, station_name=station_names_fiveg, vlan_id=vlan) From 3269ba8455aba78bbb2e2afc44335b3a2dc0b02b Mon Sep 17 00:00:00 2001 From: shivamcandela Date: Fri, 21 May 2021 17:22:11 +0530 Subject: [PATCH 19/21] fixture fixes Signed-off-by: shivamcandela --- tests/conftest.py | 167 ++++-------------------------- tests/e2e/basic/test_something.py | 2 +- 2 files changed, 22 insertions(+), 147 deletions(-) diff --git a/tests/conftest.py b/tests/conftest.py index d24603b50..80a89bc3c 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -5,21 +5,6 @@ import os import time import allure -for folder in 'py-json', 'py-scripts': - if folder not in sys.path: - sys.path.append(f'../lanforge/lanforge-scripts/{folder}') - -sys.path.append(f"../lanforge/lanforge-scripts/py-scripts/tip-cicd-sanity") - -sys.path.append(f'../libs') -sys.path.append(f'../libs/lanforge/') - -from LANforge.LFUtils import * - -if 'py-json' not in sys.path: - sys.path.append('../py-scripts') - - sys.path.append( os.path.dirname( os.path.realpath(__file__) @@ -52,13 +37,10 @@ from configuration import CONFIGURATION from configuration import FIRMWARE from testrails.testrail_api import APIClient from testrails.reporting import Reporting -<<<<<<< HEAD -from cv_test_manager import cv_test -======= import sta_connect2 from sta_connect2 import StaConnect2 +from cv_test_manager import cv_test ->>>>>>> staging-wifi-1960 def pytest_addoption(parser): parser.addini("tr_url", "Test Rail URL") @@ -104,41 +86,6 @@ def pytest_addoption(parser): default=False, help="Stop using Testrails" ) - parser.addoption( - "--exit-on-fail", - action="store_true", - default=False, - help="use to stop execution if failure" - ) - - # Perfecto Parameters - parser.addini("perfectoURL", "Cloud URL") - parser.addini("securityToken", "Security Token") - parser.addini("platformName-iOS", "iOS Platform") - parser.addini("platformName-android", "Android Platform") - parser.addini("model-iOS", "iOS Devices") - parser.addini("model-android", "Android Devices") - parser.addini("bundleId-iOS", "iOS Devices") - parser.addini("bundleId-iOS-Settings", "iOS Settings App") - parser.addini("appPackage-android", "Android Devices") - parser.addini("wifi-SSID-5gl-Pwd", "Wifi 5g Password") - parser.addini("wifi-SSID-2g-Pwd", "Wifi 2g Password") - parser.addini("Default-SSID-5gl-perfecto-b", "Wifi 5g AP Name") - parser.addini("Default-SSID-2g-perfecto-b", "Wifi 2g AP Name") - parser.addini("Default-SSID-perfecto-b", "Wifi AP Name") - parser.addini("bundleId-iOS-Ping", "Ping Bundle ID") - parser.addini("browserType-iOS", "Mobile Browser Name") - parser.addini("projectName", "Project Name") - parser.addini("projectVersion", "Project Version") - parser.addini("jobName", "CI Job Name") - parser.addini("jobNumber", "CI Job Number") - parser.addini("reportTags", "Report Tags") - parser.addoption( - "--access-points-perfecto", - # nargs="+", - default=["Perfecto"], - help="list of access points to test" - ) """ @@ -340,87 +287,6 @@ def update_report(request, testbed, get_configuration): else: projId = tr_client.get_project_id(project_name=request.config.getini("tr_project_id")) test_run_name = request.config.getini("tr_prefix") + testbed + "_" + str( -<<<<<<< HEAD - datetime.date.today()) + "_" + get_latest_firmware - instantiate_testrail.create_testrun(name=test_run_name, case_ids=list(TEST_CASES.values()), project_id=projId, - milestone_id=request.config.getini("milestone"), - description="Automated Nightly Sanity test run for new firmware build") - rid = instantiate_testrail.get_run_id(test_run_name=test_run_name) - yield rid - - -@pytest.fixture(scope="session") -def check_lanforge_connectivity(testbed): - lanforge_ip = CONFIGURATION[testbed]['traffic_generator']['details']['ip'] - lanforge_port = CONFIGURATION[testbed]['traffic_generator']['details']['port'] - - try: - cv = cv_test(lanforge_ip,lanforge_port) - url_data = cv.get_ports("/") - lanforge_GUI_version = url_data["VersionInfo"]["BuildVersion"] - lanforge_gui_git_version = url_data["VersionInfo"]["GitVersion"] - lanforge_gui_build_date = url_data["VersionInfo"]["BuildDate"] - print(lanforge_GUI_version,lanforge_gui_build_date,lanforge_gui_git_version) - if not (lanforge_GUI_version or lanforge_gui_build_date or lanforge_gui_git_version): - yield False - else: - yield True - except: - yield False - - -@pytest.fixture(scope="session") -def exit_on_fail(request): - yield request.config.getoption("--exit-on-fail") - - -@pytest.fixture(scope="session") -def setup_perfecto_devices(request): - yield True - - -@pytest.fixture(scope="session") -def test_cases(): - yield TEST_CASES - - -@pytest.fixture(scope="session") -def apnos_obj(get_configuration, testbed): - yield APNOS(get_configuration[testbed]['access_point'][0]) - - -@pytest.fixture(scope="session") -def instantiate_access_point(testbed): - APNOS(CONFIGURATION[testbed]['access_point'][0], pwd="../libs/apnos/") - yield True - - -@pytest.fixture(scope="function") -def access_point_connectivity(apnos_obj, get_configuration, testbed): - ap_conn = {} - config_serial = get_configuration[testbed]['access_point'][0]['serial'] - ap_serial = apnos_obj.get_serial_number() - ap_conn["serial"] = True - if ap_serial != config_serial: - ap_conn["serial"] = False - - ap_conn["redir"] = False - ap_redir = apnos_obj.get_redirector() - - # Compare with something ... - - ap_conn["mgr"] = False - status = apnos_obj.get_manager_state() - if "ACTIVE" not in status: - apnos_obj.run_generic_command(cmd="service opensync restart") - time.sleep(30) - status = apnos_obj.get_manager_state() - if "ACTIVE" in status: - ap_conn["mgr"] = True - else: - ap_conn["mgr"] = True - yield ap_conn -======= datetime.date.today()) + "_" + get_configuration['access_point'][0]['version'] tr_client.create_testrun(name=test_run_name, case_ids=list(TEST_CASES.values()), project_id=projId, milestone_id=request.config.getini("milestone"), @@ -429,7 +295,6 @@ def access_point_connectivity(apnos_obj, get_configuration, testbed): tr_client.rid = rid yield tr_client ->>>>>>> staging-wifi-1960 """ FRAMEWORK MARKER LOGIC @@ -488,15 +353,6 @@ def client_connectivity(): @pytest.fixture(scope="session") -<<<<<<< HEAD -def radius_info(): - yield RADIUS_SERVER_DATA - - -@pytest.fixture(scope="session") -def get_configuration(testbed): - yield CONFIGURATION[testbed] -======= def get_lanforge_data(get_configuration): lanforge_data = {} if get_configuration['traffic_generator']['name'] == 'lanforge': @@ -514,4 +370,23 @@ def get_lanforge_data(get_configuration): "vlan": 100 } yield lanforge_data ->>>>>>> staging-wifi-1960 + + +@pytest.fixture(scope="session") +def check_lanforge_connectivity(testbed, get_configuration): + lanforge_ip = get_configuration['traffic_generator']['details']['ip'] + lanforge_port = get_configuration['traffic_generator']['details']['port'] + + try: + cv = cv_test(lanforge_ip, lanforge_port) + url_data = cv.get_ports("/") + lanforge_GUI_version = url_data["VersionInfo"]["BuildVersion"] + lanforge_gui_git_version = url_data["VersionInfo"]["GitVersion"] + lanforge_gui_build_date = url_data["VersionInfo"]["BuildDate"] + print(lanforge_GUI_version, lanforge_gui_build_date, lanforge_gui_git_version) + if not (lanforge_GUI_version or lanforge_gui_build_date or lanforge_gui_git_version): + yield False + else: + yield True + except: + yield False diff --git a/tests/e2e/basic/test_something.py b/tests/e2e/basic/test_something.py index 23d799f9c..8c9a9c076 100644 --- a/tests/e2e/basic/test_something.py +++ b/tests/e2e/basic/test_something.py @@ -2,5 +2,5 @@ import pytest @pytest.mark.test_lanforge_connectivity -def test_cv(create_lanforge_chamberview): +def test_cv(check_lanforge_connectivity): assert True From 961da9b062be6e256c98dd98674836baed861a4b Mon Sep 17 00:00:00 2001 From: shivamcandela Date: Fri, 21 May 2021 17:23:36 +0530 Subject: [PATCH 20/21] added configuration file parameters Signed-off-by: shivamcandela --- tests/configuration.py | 132 ++++++++++++++--------------------------- 1 file changed, 43 insertions(+), 89 deletions(-) diff --git a/tests/configuration.py b/tests/configuration.py index 6c9e53c44..fff97989e 100644 --- a/tests/configuration.py +++ b/tests/configuration.py @@ -1,7 +1,40 @@ +""" +ec420 basic-03 +ecw5410 basic-01 +ecw5211 not available in basic +wf188n basic-05 +eap102 basic-06 +eap101 basic-02 +wf194c baisc-08-02 + +ssh -C -L 8800:lf1:4002 -L 8801:lf1:5901 -L 8802:lf1:8080 -L 8803:lab-ctlr:22 \ # basic-01 +-L 8720:lf2:4002 -L 8721:lf2:5901 -L 8722:lf2:8080 -L 8723:lab-ctlr:22 \ # basic-02 +-L 8830:lf3:4002 -L 8831:lf3:5901 -L 8832:lf3:8080 -L 8833:lab-ctlr:22 \ # basic-03 +-L 8810:lf4:4002 -L 8811:lf4:5901 -L 8812:lf4:8080 -L 8813:lab-ctlr:22 \ # basic-04 +-L 8850:lf12:4002 -L 8851:lf12:5901 -L 8852:lf12:8080 -L 8853:lab-ctlr4:22 \ # basic-05 +-L 8860:lf13:4002 -L 8861:lf13:5901 -L 8862:lf13:8080 -L 8863:lab-ctlr4:22 \ # basic-06 +-L 8870:lf14:4002 -L 8871:lf14:5901 -L 8872:lf14:8080 -L 8873:lab-ctlr4:22 \ # basic-07 +-L 8880:lf15:4002 -L 8881:lf15:5901 -L 8882:lf15:8080 -L 8883:lab-ctlr4:22 \ # basic-08 +ubuntu@3.130.51.163 + + + +ssh -C -L 8800:lf1:4002 -L 8801:lf1:5901 -L 8802:lf1:8080 -L 8803:lab-ctlr:22 \ +-L 8720:lf2:4002 -L 8721:lf2:5901 -L 8722:lf2:8080 -L 8723:lab-ctlr:22 \ +-L 8830:lf3:4002 -L 8831:lf3:5901 -L 8832:lf3:8080 -L 8833:lab-ctlr:22 \ +-L 8810:lf4:4002 -L 8811:lf4:5901 -L 8812:lf4:8080 -L 8813:lab-ctlr:22 \ +-L 8850:lf12:4002 -L 8851:lf12:5901 -L 8852:lf12:8080 -L 8853:lab-ctlr4:22 \ +-L 8860:lf13:4002 -L 8861:lf13:5901 -L 8862:lf13:8080 -L 8863:lab-ctlr4:22 \ +-L 8870:lf14:4002 -L 8871:lf14:5901 -L 8872:lf14:8080 -L 8873:lab-ctlr4:22 \ +-L 8880:lf15:4002 -L 8881:lf15:5901 -L 8882:lf15:8080 -L 8883:lab-ctlr4:22 \ +ubuntu@3.130.51.163 + +""" + CONFIGURATION = { - "basic-ext-03-01": { + "basic-ext-04-01": { "controller": { - 'url': "https://wlan-portal-svc-nola-ext-03.cicd.lab.wlan.tip.build", # API base url for the controller + 'url': "https://wlan-portal-svc-nola-ext-04.cicd.lab.wlan.tip.build", # API base url for the controller 'username': 'support@example.com', 'password': 'support', 'version': "1.1.0-SNAPSHOT", @@ -11,107 +44,33 @@ CONFIGURATION = { { 'model': 'ecw5410', 'mode': "wifi5", - 'serial': '903cb3944807', - 'jumphost': True, - 'ip': "192.168.200.230", - 'username': "lanforge", - 'password': "lanforge", - 'port': 22, - 'jumphost_tty': '/dev/ttyAP1', - 'version': "ecw5410-2021-03-30-pending-9cb289b" - } - ], - "traffic_generator": { - "name": "lanforge", - "details": { - "ip": "localhost", - "port": 8080, - "2.4G-Radio": ["wiphy0"], - "5G-Radio": ["wiphy1"], - "AX-Radio": ["wiphy2"], - "upstream": "eth1", - "2.4G-Station-Name": "wlan0", - "5G-Station-Name": "wlan1", - "AX-Station-Name": "ax", - } - } - }, - "basic-ext-03-02": { - "controller": { - 'url': "https://wlan-portal-svc-nola-ext-03.cicd.lab.wlan.tip.build", # API base url for the controller - 'username': 'support@example.com', - 'password': 'support', - 'version': "1.1.0-SNAPSHOT", - 'commit_date': "2021-04-27" - }, - 'access_point': [ - { - 'model': 'ecw5410', - 'mode': 'wifi5', 'serial': '903cb394486f', 'jumphost': True, - 'ip': "192.168.200.233", + 'ip': "192.168.200.81", 'username': "lanforge", 'password': "lanforge", 'port': 22, 'jumphost_tty': '/dev/ttyAP1', - 'version': "ecw5410-2021-04-26-pending-3fc41fa" + 'version': "ecw5410-2021-04-23-30496b1" } ], "traffic_generator": { "name": "lanforge", "details": { - "ip": "192.168.200.233", - "port": 8080, - "2.4G-Radio": ["wiphy0"], - "5G-Radio": ["wiphy1"], - "AX-Radio": ["wiphy2"], - "upstream": "eth1", - "2.4G-Station-Name": "wlan0", - "5G-Station-Name": "wlan1", - "AX-Station-Name": "ax", - } - } - }, - "basic-ext-03-03": { - "controller": { - 'url': "https://wlan-portal-svc-nola-ext-03.cicd.lab.wlan.tip.build", # API base url for the controller - 'username': 'support@example.com', - 'password': 'support', - 'version': "1.1.0-SNAPSHOT", - 'commit_date': "2021-04-27" - }, - 'access_point': [ - { - 'model': 'ecw5410', - 'mode': 'wifi5', - 'serial': '903cb3944857', - 'jumphost': True, - 'ip': "192.168.200.80", - 'username': "lanforge", - 'password': "lanforge", - 'port': 22, - 'jumphost_tty': '/dev/ttyAP1', - 'version': "ecw5410-2021-04-26-pending-3fc41fa" - } - ], - "traffic_generator": { - "name": "lanforge", - "details": { - "ip": "192.168.200.80", + "ip": "192.168.200.81", "port": 8080, "2.4G-Radio": ["wiphy0"], "5G-Radio": ["wiphy1"], "AX-Radio": ["wiphy2"], "upstream": "1.1.eth1", - "uplink": "1.1.eth2", - "upstream_subnet": "192.168.200.1/24", + "upstream_subnet": "192.168.200.0/24", + "uplink" : "1.1.eth2", "2.4G-Station-Name": "wlan0", "5G-Station-Name": "wlan0", "AX-Station-Name": "ax", } } - }, + } } FIRMWARE = { @@ -119,16 +78,14 @@ FIRMWARE = { "JFROG": { "jfrog-base-url": "https://tip.jFrog.io/artifactory/tip-wlan-ap-firmware", - "username": "tip-read", - "password": "tip-read", "build": "pending", - "branch": "dev" + "branch": "trunk" } } RADIUS_SERVER_DATA = { - "ip": "10.28.3.100", + "ip": "192.168.200.75", "port": 1812, "secret": "testing123", "user": "nolaradius", @@ -193,6 +150,3 @@ TEST_CASES = { "nat_ssid_update": 8743, "vlan_ssid_update": 8744 } -# cmd = /bin/wlan_ap_redirector.sh ssl:opensync-redirector-nola-01.cicd.lab.wlan.tip.build:6643 -# radius server -# radsec From 7fb54160e33d01cd8a1ad73933699f7c22136ed0 Mon Sep 17 00:00:00 2001 From: shivamcandela Date: Fri, 21 May 2021 22:47:03 +0530 Subject: [PATCH 21/21] conftest changes and connectivity changes Signed-off-by: shivamcandela --- tests/conftest.py | 47 ++++++++++++++++++------------- tests/e2e/basic/test_something.py | 6 ---- tests/test_connectivity.py | 27 ++++++++++++++---- 3 files changed, 49 insertions(+), 31 deletions(-) delete mode 100644 tests/e2e/basic/test_something.py diff --git a/tests/conftest.py b/tests/conftest.py index 80a89bc3c..aceefe3b2 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -168,7 +168,7 @@ def instantiate_access_point(testbed, get_apnos, get_configuration): # Controller Fixture @pytest.fixture(scope="session") -def setup_controller(request, get_configuration, instantiate_access_point): +def setup_controller(request, get_configuration, instantiate_access_point, traffic_generator_connectivity): try: sdk_client = Controller(controller_data=get_configuration["controller"]) allure.attach(body=str(get_configuration["controller"]), name="Controller Instantiated: ") @@ -336,8 +336,8 @@ def test_access_point(testbed, get_apnos, get_configuration): mgr_status = [] for access_point_info in get_configuration['access_point']: ap_ssh = get_apnos(access_point_info) - ap_ssh.reboot() - time.sleep(100) + # ap_ssh.reboot() + # time.sleep(100) status = ap_ssh.get_manager_state() if "ACTIVE" not in status: time.sleep(30) @@ -373,20 +373,29 @@ def get_lanforge_data(get_configuration): @pytest.fixture(scope="session") -def check_lanforge_connectivity(testbed, get_configuration): - lanforge_ip = get_configuration['traffic_generator']['details']['ip'] - lanforge_port = get_configuration['traffic_generator']['details']['port'] - - try: - cv = cv_test(lanforge_ip, lanforge_port) - url_data = cv.get_ports("/") - lanforge_GUI_version = url_data["VersionInfo"]["BuildVersion"] - lanforge_gui_git_version = url_data["VersionInfo"]["GitVersion"] - lanforge_gui_build_date = url_data["VersionInfo"]["BuildDate"] - print(lanforge_GUI_version, lanforge_gui_build_date, lanforge_gui_git_version) - if not (lanforge_GUI_version or lanforge_gui_build_date or lanforge_gui_git_version): +def traffic_generator_connectivity(testbed, get_configuration): + if get_configuration['traffic_generator']['name'] == "lanforge": + lanforge_ip = get_configuration['traffic_generator']['details']['ip'] + lanforge_port = get_configuration['traffic_generator']['details']['port'] + # Condition : + # if gui connection is not available + # yield False + # Condition : + # If Gui Connection is available + # yield the gui version + try: + cv = cv_test(lanforge_ip, lanforge_port) + url_data = cv.get_ports("/") + lanforge_GUI_version = url_data["VersionInfo"]["BuildVersion"] + lanforge_gui_git_version = url_data["VersionInfo"]["GitVersion"] + lanforge_gui_build_date = url_data["VersionInfo"]["BuildDate"] + print(lanforge_GUI_version, lanforge_gui_build_date, lanforge_gui_git_version) + if not (lanforge_GUI_version or lanforge_gui_build_date or lanforge_gui_git_version): + yield False + else: + yield True + except: yield False - else: - yield True - except: - yield False + else: + # Writing the connectivity check of InterOP + yield True \ No newline at end of file diff --git a/tests/e2e/basic/test_something.py b/tests/e2e/basic/test_something.py deleted file mode 100644 index 8c9a9c076..000000000 --- a/tests/e2e/basic/test_something.py +++ /dev/null @@ -1,6 +0,0 @@ -import pytest - - -@pytest.mark.test_lanforge_connectivity -def test_cv(check_lanforge_connectivity): - assert True diff --git a/tests/test_connectivity.py b/tests/test_connectivity.py index 42073ffe2..4cae970be 100644 --- a/tests/test_connectivity.py +++ b/tests/test_connectivity.py @@ -1,8 +1,6 @@ """ Test Case Module: Testing Basic Connectivity with Resources """ -import sys - import allure import pytest @@ -25,24 +23,23 @@ class TestResources(object): allure.attach(name="Controller Connectivity Failed", body="") update_report.update_testrail(case_id=test_cases["cloud_ver"], status_id=0, msg='Could not read CloudSDK version from API') - pytest.exit("Resource Not Available") - # print(setup_controller.bearer) + pytest.exit("Controller Not Available") assert setup_controller.bearer @pytest.mark.test_access_points_connectivity @allure.testcase(name="test_access_points_connectivity", url="") def test_access_points_connectivity(self, test_access_point, update_report, test_cases): + flag = True for i in test_access_point: if "ACTIVE" not in i: flag = False - if flag is False: allure.attach(name="Access Point Connectivity Success", body=str(test_access_point)) update_report.update_testrail(case_id=test_cases["cloud_connection"], status_id=5, msg='CloudSDK connectivity failed') - pytest.exit("Access Point Manafer state is not ACtive") + pytest.exit("Access Point Manager state is not Active") else: allure.attach(name="Access Point Connectivity Failed", body=str(test_access_point)) update_report.update_testrail(case_id=test_cases["cloud_connection"], @@ -51,3 +48,21 @@ class TestResources(object): assert flag + @pytest.mark.traffic_generator_connectivity + @allure.testcase(name="test_traffic_generator_connectivity", url="") + def test_traffic_generator_connectivity(self, traffic_generator_connectivity, update_report, test_cases): + + if traffic_generator_connectivity is False: + allure.attach(name="Access Point Connectivity Success", body=str(traffic_generator_connectivity)) + update_report.update_testrail(case_id=test_cases["cloud_connection"], + status_id=5, + msg='CloudSDK connectivity failed') + + pytest.exit("Traffic Generator is not Available") + else: + allure.attach(name="Access Point Connectivity Failed", body=str(traffic_generator_connectivity)) + update_report.update_testrail(case_id=test_cases["cloud_connection"], + status_id=1, + msg='Manager status is Active') + + assert traffic_generator_connectivity