def test_001_check_add_one_list(self):
"""添加一条IP过滤规则,PC的ip在范围之内,PC不能访问internet"""
#首先启用无线网卡
tmp = IPFilterBusiness(self.driver)
tmp.wlan_enable(data_basic['wlan_pc'])
#刷新页面重新登录ap页面
Lg = LoginBusiness(self.driver)
Lg.refresh_login_ap()
#把AP恢复出厂配置
tmp1 = ConfigUpdateBusiness(self.driver)
tmp1.restore_AP_factory()
#重新登录AP
#逻辑类对象，建一个实例
Lg = LoginBusiness(self.driver)
#调用实例的登录AP的web界面
Lg.login(data_basic['superUser'], data_basic['super_defalut_pwd'])
#刷新页面重新登录ap页面
Lg.refresh_login_ap()
#先确定PC能够上网
result1 = tmp.get_ping("www.baidu.com")
#获取PC lan口附近的ip地址
start_end_ip = tmp.obtain_lan_ip_near_ip(data_basic['lan_pc'], 5, 5)
#添加一条IP过滤规则,PC的ip在范围之内
tmp.add_one_IPFilter_list(*start_end_ip)
#判断PC是否能够上网
result2 = tmp.get_ping("www.baidu.com")
self.assertEqual(result1, 0)
self.assertNotEqual(result2, 0)
log.debug("001\t\tpass")
def check_STA_unblock_no_need_auth(self, ssid, password, wlan, eth):
#无线STA通过group0的认证
tmp = CPBusiness(self.driver)
tmp.access_No_auth_portal(ssid, password, wlan, eth, "wpa")
#无线网卡释放ip地址
CPControl.dhcp_release_wlan(self, wlan)
#断开无线连接
CPControl.disconnect_ap(self)
#启用有线网卡
CPControl.wlan_enable(self, eth)
#刷新页面重新登录ap页面
Lg = LoginBusiness(self.driver)
Lg.refresh_login_ap()
#block STA
tmp.connect_WPA_AP(ssid, password, wlan)
tmp3 = ClientsBusiness(self.driver)
wlan_mac = tmp3.get_wlan_mac(wlan)
tmp3.block_client(wlan_mac)
#unblock STA
tmp4 = ClientAccessBusiness(self.driver)
#删除Global Blacklist里面的所有的mac
tmp4.del_Global_Blacklist_mac()
#使用免认证的规则，腾讯首页，判断是否跳转到portal页面
result = tmp.check_jump_to_No_auth_portal(ssid, password, wlan, eth)
return result
def test_001_check_add_one_list_not_access_url(self):
"""添加一条url过滤规则,PC不能够访问指定的url"""
#首先启用无线网卡
tmp = UrlFilterBusiness(self.driver)
tmp.wlan_enable(data_basic['wlan_pc'])
#刷新页面重新登录ap页面
Lg = LoginBusiness(self.driver)
Lg.refresh_login_ap()
#把AP恢复出厂配置
tmp1 = ConfigUpdateBusiness(self.driver)
tmp1.restore_AP_factory()
#重新登录AP
#逻辑类对象，建一个实例
Lg = LoginBusiness(self.driver)
#调用实例的登录AP的web界面
Lg.login(data_basic['superUser'], data_basic['super_defalut_pwd'])
#刷新页面重新登录ap页面
Lg.refresh_login_ap()
#先确定PC能够访问指定的url--baidu
result1 = tmp.check_access_url("www.baidu.com")
#添加一条url过滤规则--baidu
tmp.add_one_list("baidu")
#确定PC不能够访问指定的url--baidu
result2 = tmp.check_access_url("www.baidu.com")
self.assertTrue(result1)
self.assertFalse(result2)
log.debug("001\t\tpass")
def check_group1_radius_portal_function(self, NG2_ssid, password, wlan,
eth, t, radius_name,
radius_password):
#7000新建一个网络组，vid设为2,开启dhcp server
tmp1 = NGBusiness(self.driver)
tmp1.mixed_7000_new_NG()
#76xx上新建一个网络组，vid为2
self.driver.get(data_basic['DUT_web'])
self.driver.implicitly_wait(60)
self.driver.refresh()
time.sleep(10)
tmp3 = SSIDBusiness(self.driver)
tmp3.new_vlan_ssid(NG2_ssid, password, "2")
#开启ssid1的强制门户认证
tmp3.click_ssid_portal(2)
#master ap加入所有的网络组
tmp2 = APSBusiness(self.driver)
tmp2.add_master_to_all_NG()
#验证默认list：grandstream中的radius认证的有效性
portal_title,redirect_title,again_title,expiration_title = \
CPBusiness.check_radius_portal(self,NG2_ssid,password,
wlan,eth,t,radius_name,radius_password)
#刷新页面重新登录ap页面
Lg = LoginBusiness(self.driver)
Lg.refresh_login_ap()
#删除master ap的ssid1
tmp3.del_all_NG()
#删除7000新建的网络组
tmp1.mixed_7000_del_NG()
return portal_title, redirect_title, again_title, expiration_title
def check_portal_client_block_function(self, ssid, password, wlan, eth):
#通过免认证方式上网
CPBusiness.\
access_No_auth_portal(self,ssid,password,wlan,eth,"wpa")
#无线网卡释放ip地址
CPControl.dhcp_release_wlan(self, wlan)
#断开无线连接
CPControl.disconnect_ap(self)
#启用有线网卡
CPControl.wlan_enable(self, eth)
tmp = ClientsBusiness(self.driver)
#使用无线网卡能够连接上ssid,并正常使用
tmp.connect_DHCP_WPA_AP(ssid, password, wlan)
#无线网卡释放ip地址
CPControl.dhcp_release_wlan(self, wlan)
#刷新页面重新登录ap页面
Lg = LoginBusiness(self.driver)
Lg.refresh_login_ap()
#只有一个客户端，阻塞该客户端
wlan_mac = tmp.get_wlan_mac(wlan)
tmp.block_client(wlan_mac)
time.sleep(60)
#测试机上判断无线客户端是否依然是连接上的
result = tmp.get_client_cmd_result("iw dev %s link" % wlan)
#无线网卡释放ip地址
CPControl.dhcp_release_wlan(self, wlan)
#断开无线连接
CPControl.disconnect_ap(self)
#刷新页面重新登录ap页面
Lg = LoginBusiness(self.driver)
Lg.refresh_login_ap()
tmp1 = ClientAccessBusiness(self.driver)
#删除Global Blacklist里面的所有的mac
tmp1.del_Global_Blacklist_mac()
return result
def check_open_close_many_groups_captive_portal_function(
self, group0_ssid, group1_ssid, group2_ssid, password, wlan, eth):
result = []
tmp1 = SSIDBusiness(self.driver)
for i in range(2):
#点击group0的强制门户认证
#点击三个网络组的强制门户认证
tmp1.click_many_group_portal(3)
#使用免认证的规则，访问腾讯首页，判断是否跳转到portal页面
for j in [group0_ssid, group1_ssid, group2_ssid]:
result1 = CPBusiness.check_jump_to_No_auth_portal(
self, j, password, wlan, eth)
result.append(result1)
#测试完成一遍后，再次登录ap页面，为后续循环测试做好准备
#刷新页面重新登录ap页面
Lg = LoginBusiness(self.driver)
Lg.refresh_login_ap()
time.sleep(30)
#删除master ap的两个ssid
tmp1 = SSIDBusiness(self.driver)
tmp1.del_all_NG()
#删除7000新建的两个网络组
tmp2 = NGBusiness(self.driver)
tmp2.mixed_7000_del_NG()
print result
return result
def check_slave_ap_group1_portal_function(self, NG2_ssid, password, wlan,
eth):
#7000新建一个网络组，vid设为2,开启dhcp server
tmp1 = NGBusiness(self.driver)
tmp1.mixed_7000_new_NG()
#76xx上新建一个网络组，vid为2
self.driver.get(data_basic['DUT_web'])
self.driver.implicitly_wait(60)
self.driver.refresh()
time.sleep(10)
tmp2 = SSIDBusiness(self.driver)
tmp2.new_vlan_ssid(NG2_ssid, password, "2")
#开启group1的强制门户认证
tmp2.click_ssid_portal(2)
#slave ap加入所有的网络组
tmp3 = APSBusiness(self.driver)
tmp3.add_slave_to_all_NG()
#使用免认证的规则，访问腾讯首页，判断是否跳转到portal页面
result = CPBusiness.check_jump_to_No_auth_portal(
self, NG2_ssid, password, wlan, eth)
#刷新页面重新登录ap页面
Lg = LoginBusiness(self.driver)
Lg.refresh_login_ap()
#删除ssid1
tmp2.del_all_NG()
#删除7000新建的网络组
tmp1.mixed_7000_del_NG()
print result
return result
def check_group1_open_DHCP_portal_function(self, NG2_name, ip, start_ip,
end_ip, gateway, dns1, NG2_ssid,
password, wlan, eth):
#7000新建一个网络组，vid设为2,不开启dhcp server
tmp1 = NGBusiness(self.driver)
tmp1.mixed_7000_new_NG_no_DHCP()
#76xx上新建一个网络组，vid为2,开启dhcp server和wifi
self.driver.get(data_basic['DUT_web'])
self.driver.implicitly_wait(60)
self.driver.refresh()
time.sleep(10)
tmp1.new_group_open_dhcp_server(NG2_name, ip, start_ip, end_ip,
gateway, dns1, NG2_ssid, password)
#开启group1的强制门户认证
tmp1.click_groupn_portal(1)
#使用免认证的规则，访问腾讯首页，判断是否跳转到portal页面
result = CPBusiness.check_jump_to_No_auth_portal(
self, NG2_ssid, password, wlan, eth)
#刷新页面重新登录ap页面
Lg = LoginBusiness(self.driver)
Lg.refresh_login_ap()
#删除master ap的group1
tmp1.del_all_NG()
#删除7000新建的网络组
tmp1.mixed_7000_del_NG()
print result
return result
def test_002_set_wan_staticIP(self):
"""外网设置为静态IP，能否上网"""
tmp = WanSettingsBusiness(self.driver)
#设置外网为staticIP
tmp.change_wan_to_staticIP(data_wan['static_IP'], data_wan['netmask'],
data_wan['gateway'], data_wan['DNS'])
#判断ap能够上网
time.sleep(30)
#逻辑类对象，建一个实例
Lg = LoginBusiness(self.driver)
#刷新页面重新登录ap页面
Lg.refresh_login_ap()
tmp1 = StateInfoBusiness(self.driver)
#获取当前模式
result1 = tmp1.obtain_AP_current_mode()
#获取外网的IP获取方式
result2 = tmp1.obtain_WAN_IP_generation()
#获取IP地址
result3 = tmp1.obtain_WAN_IP_address()
result4 = tmp.get_ping("www.baidu.com")
self.assertEqual(result1, "路由模式")
self.assertEqual(result2, "静态IP")
self.assertEqual(data_wan['static_IP'], result3)
self.assertEqual(0, result4)
log.debug("002\t\tpass")
def test_003_set_wan_dhcp(self):
"""外网设置为动态获取，能否上网"""
tmp = WanSettingsBusiness(self.driver)
#设置外网为动态获取
tmp.change_wan_to_dhcp()
time.sleep(30)
#逻辑类对象，建一个实例
Lg = LoginBusiness(self.driver)
#刷新页面重新登录ap页面
Lg.refresh_login_ap()
tmp1 = StateInfoBusiness(self.driver)
#获取当前模式
result1 = tmp1.obtain_AP_current_mode()
#获取外网的IP获取方式
result2 = tmp1.obtain_WAN_IP_generation()
#获取IP地址
result3 = tmp1.obtain_WAN_IP_address()
#判断ap能够上网
result4 = tmp.get_ping("www.baidu.com")
tmp.disconnect_ap()
self.assertEqual(result1, "路由模式")
self.assertEqual(result2, "动态获取")
self.assertIn(data_wan['wan_str'], result3)
self.assertEqual(0, result4)
log.debug("003\t\tpass")
def test_001_disable_dhcp_server(self):
"""禁用dhcp server，client无法获取到ip地址"""
#首先启用无线网卡
tmp = LanSettingsBusiness(self.driver)
tmp.wlan_enable(data_basic['wlan_pc'])
#刷新页面重新登录ap页面
Lg = LoginBusiness(self.driver)
Lg.refresh_login_ap()
#把AP恢复出厂配置
tmp1 = ConfigUpdateBusiness(self.driver)
tmp1.restore_AP_factory()
#重新登录AP
#逻辑类对象，建一个实例
Lg = LoginBusiness(self.driver)
#调用实例的登录AP的web界面
Lg.login(data_basic['superUser'], data_basic['super_defalut_pwd'])
#刷新页面重新登录ap页面
Lg.refresh_login_ap()
#关闭ap的dhcp server
tmp.enable_disable_dhcp_server(0)
result = tmp.check_AP_dhcp_server(data_basic['lan_pc'], "192.168.1")
#指定有线网卡的固定ip--能够访问ap的webpage
tmp.set_eth_ip(data_basic['lan_pc'], data_basic['static_PC_ip'])
self.assertFalse(result)
log.debug("001\t\tpass")
def test_001_check_wifi_upload(self):
"""判断WIFI总上行是否正确"""
#首先启用无线网卡
tmp2 = WirelessSettingsBusiness(self.driver)
tmp2.wlan_enable(data_basic['wlan_pc'])
#刷新页面重新登录ap页面
Lg = LoginBusiness(self.driver)
Lg.refresh_login_ap()
#把AP恢复出厂配置
tmp1 = ConfigUpdateBusiness(self.driver)
tmp1.restore_AP_factory()
#重新登录AP
#逻辑类对象，建一个实例
Lg = LoginBusiness(self.driver)
#调用实例的登录AP的web界面
Lg.login(data_basic['superUser'], data_basic['super_defalut_pwd'])
#刷新页面重新登录ap页面
Lg.refresh_login_ap()
#修改无线的ssid,加密方式和密码
tmp2.change_wifi_ssid_encryption_pwd(data_wirless['all_ssid'], "psk2",
data_wirless['short_wpa'])
#判断WIFI总上行是否正确
tmp = StateInfoBusiness(self.driver)
result = tmp.check_wifi_upload(data_wirless['all_ssid'],
data_wirless['short_wpa'],
data_basic['wlan_pc'],
data_basic['lan_pc'])
self.assertTrue(result)
log.debug("001\t\tpass")
def test_004_check_apmode_reboot_ap(self):
"""AP模式下在页面上点击重启设备后，验证设备是否重启"""
tmp1 = WorkModeBusiness(self.driver)
#设置PC的静态IP,能够访问DUT的webpage
tmp1.set_eth_ip(data_basic['lan_pc'], data_basic['static_PC_ip'])
#修改工作模式为AP模式,内网设置静态IP
tmp1.change_workmode_to_ap_LANstaticIP(data_basic['DUT_ip'],
data_lan['netmask1'],
data_wirless['all_ssid'],
"psk2",
data_wirless['short_wpa'],
"HT20")
#time.sleep(30)
#逻辑类对象，建一个实例
Lg = LoginBusiness(self.driver)
#刷新页面重新登录ap页面
Lg.refresh_login_ap()
#登录ap后台，判断ap的工作模式
result5 = tmp1.check_DUT_workmode(data_basic['DUT_ip'],
data_basic['ssh_user'],
data_basic['ssh_pwd'])
tmp = RebootSystemBusiness(self.driver)
#在页面上点击重启设备后，验证设备是否重启
result1, result2 = tmp.check_reboot_ap(data_basic['DUT_ip'])
self.assertIn("ap", result5)
self.assertNotEqual(0, result1)
self.assertEqual(0, result2)
log.debug("004\t\tpass")
def test_001_default_wifi(self):
"""默认无线开关为开启状态"""
# #首先启用无线网卡
tmp = WirelessSettingsBusiness(self.driver)
tmp.wlan_enable(data_basic['wlan_pc'])
#刷新页面重新登录ap页面
Lg = LoginBusiness(self.driver)
Lg.refresh_login_ap()
#把AP恢复出厂配置
tmp1 = ConfigUpdateBusiness(self.driver)
tmp1.restore_AP_factory()
#重新登录AP
#逻辑类对象，建一个实例
Lg = LoginBusiness(self.driver)
#调用实例的登录AP的web界面
Lg.login(data_basic['superUser'], data_basic['super_defalut_pwd'])
#刷新页面重新登录ap页面
Lg.refresh_login_ap()
#使用无线网卡扫描，能够连接上默认ssid
#默认ssid
default_ssid = "3ONE_2G_" + data.master_last_6mac()
print(default_ssid)
result = tmp.client_connect_ssid(default_ssid, data_basic['wlan_pc'],
"open")
#result = tmp.ssid_scan_result_backup(default_ssid, data_basic['wlan_pc'])
self.assertTrue(result)
log.debug("001\t\tpass")
def test_005_apmode_save_config_file(self):
"""AP模式下保存配置"""
tmp = WorkModeBusiness(self.driver)
#设置PC的静态IP,能够访问DUT的webpage
tmp.set_eth_ip(data_basic['lan_pc'], data_basic['static_PC_ip'])
#修改工作模式为AP模式,内网设置静态IP
tmp.change_workmode_to_ap_LANstaticIP(data_basic['DUT_ip'],
data_lan['netmask1'], data_wirless['all_ssid'], "psk2",
data_wirless['short_wpa'], "HT20")
time.sleep(30)
#逻辑类对象，建一个实例
Lg = LoginBusiness(self.driver)
#刷新页面重新登录ap页面
Lg.refresh_login_ap()
#下载配置文件
tmp1 = ConfigUpdateBusiness(self.driver)
tmp1.download_config_file()
#判断配置文件是否下载
#文件路径
PATH = os.path.join(os.getcwd(), "bakup.file")
print(PATH)
result = os.path.exists(PATH)
#登录ap后台，判断ap的工作模式
result5 = tmp.check_DUT_workmode(data_basic['DUT_ip'], data_basic['ssh_user'],
data_basic['ssh_pwd'])
self.assertTrue(result)
self.assertIn("ap", result5)
log.debug("005\t\tpass")
def test_013_clientmode_save_config_file(self):
"""客户端模式下保存配置"""
tmp = WorkModeBusiness(self.driver)
#修改工作模式为client模式,内网设置静态IP,桥接ap无线加密为wpa2
tmp.change_workmode_to_client_LANstaticIP(data_basic['DUT_ip'], data_lan['netmask1'],
data_wirless['bridge_essid'], data_wirless['bridge_encryption'],
data_wirless['bridge_bssid'], data_wirless['bridge_pwd'],
data_basic['ssh_user'], data_basic['ssh_pwd'])
#逻辑类对象，建一个实例
Lg = LoginBusiness(self.driver)
#刷新页面重新登录ap页面
Lg.refresh_login_ap()
#下载配置文件
tmp1 = ConfigUpdateBusiness(self.driver)
tmp1.download_config_file()
#判断配置文件是否下载
#文件路径
PATH = os.path.join(os.getcwd(), "bakup.file")
print(PATH)
result = os.path.exists(PATH)
#登录ap后台，判断ap的工作模式
result5 = tmp.check_DUT_workmode(data_basic['DUT_ip'], data_basic['ssh_user'],
data_basic['ssh_pwd'])
self.assertTrue(result)
self.assertIn("wds_c", result5)
log.debug("013\t\tpass")
def test_007_check_bridgemode_reboot_ap(self):
"""桥接模式下在页面上点击重启设备后，验证设备是否重启"""
tmp = WorkModeBusiness(self.driver)
#修改工作模式为bridge模式,内网设置静态IP
tmp.change_workmode_to_bridge_LANstaticIP(
data_basic['DUT_ip'], data_lan['netmask1'],
data_wirless['bridge_essid'], data_wirless['bridge_encryption'],
data_wirless['bridge_bssid'], data_wirless['bridge_pwd'],
data_wirless['all_ssid'], "psk2", data_wirless['short_wpa'],
data_basic['ssh_user'], data_basic['ssh_pwd'])
#逻辑类对象，建一个实例
Lg = LoginBusiness(self.driver)
#刷新页面重新登录ap页面
Lg.refresh_login_ap()
#登录ap后台，判断ap的工作模式
result5 = tmp.check_DUT_workmode(data_basic['DUT_ip'],
data_basic['ssh_user'],
data_basic['ssh_pwd'])
tmp = RebootSystemBusiness(self.driver)
#在页面上点击重启设备后，验证设备是否重启
result1, result2 = tmp.check_reboot_ap(data_basic['DUT_ip'])
self.assertIn("wds", result5)
self.assertNotEqual(0, result1)
self.assertEqual(0, result2)
log.debug("007\t\tpass")
def change_workmode_to_client_LANstaticIP(self, ip, netmask,
bridge_essid, bridge_encryption_mode,bridge_bssid,
bridge_pwd, user, pwd):
"""
修改工作模式为client模式,内网设置静态IP
"""
for i in range(3):
#点击工作模式菜单
self.menu_workmode()
#选择桥接模式
self.set_mode("client")
time.sleep(10)
#内网设置点击静态IP按钮
self.set_client_LAN_staticIP()
#输入静态IP的ip地址
self.set_client_LAN_staticIP_ip(ip)
#输入静态IP的子网掩码
self.set_client_LAN_staticIP_netmask(netmask)
#输入静态ip的gateway
self.set_client_LAN_staticIP_gateway("")
#点击下一步
self.click_next_button()
#桥接设置
# #点击扫描
# self.click_bridge_bridge_scan_button()
# time.sleep(10)
# #扫描页面中，根据扫描到的ap的mac地址点击对应的操作按钮
# self.set_bridge_bridge_scan_operat(bridge_bssid)
#桥接设置输入要桥接的ssid
self.set_client_bridge_ssid(bridge_essid)
#桥接设置要桥接的无线的加密方式
self.set_client_bridge_encryption(bridge_encryption_mode)
#输入桥接ap的无线密码
self.set_client_bridge_password(bridge_pwd)
#桥接设置要桥接的对端无线mac地址
self.set_client_bridge_BSSID(bridge_bssid)
#点击下一步
self.click_next_button()
#点击完成
self.click_finish_button()
time.sleep(5)
if self.check_waitbar_displayed():
time.sleep(85)
break
else:
Lg = LoginBusiness(self.driver)
#刷新页面重新登录ap页面
Lg.refresh_login_ap()
#指定有线网卡的固定ip--能够访问ap的webpage
self.dhcp_release_wlan(data_basic['lan_pc'])
self.set_eth_ip(data_basic['lan_pc'], data_basic['static_PC_ip'])
#关闭AP的eth1端口，以免她来分配ip地址，和桥接的dhcp server相冲突
self.down_ap_eth1(ip, user, pwd)
print("set client mode successfull!")
def test_007_bridgemode_system_downgrade_check_config(self):
"""桥接模式下，修改配置后，系统降级，检查配置"""
tmp1 = WorkModeBusiness(self.driver)
#修改工作模式为bridge模式,内网设置静态IP
tmp1.change_workmode_to_bridge_LANstaticIP(
data_basic['DUT_ip'], data_lan['netmask1'],
data_wirless['bridge_essid'], data_wirless['bridge_encryption'],
data_wirless['bridge_bssid'], data_wirless['bridge_pwd'],
data_wirless['all_ssid'], "psk2", data_wirless['short_wpa'],
data_basic['ssh_user'], data_basic['ssh_pwd'])
time.sleep(30)
#选择固件路径，降级固件
PATH = os.path.join(
os.getcwd(), AP_model + '-' + data_basic['old_version'] + '.bin')
print(PATH)
#逻辑类对象，建一个实例
Lg = LoginBusiness(self.driver)
#刷新页面重新登录ap页面
Lg.refresh_login_ap()
tmp = SystemUpgradeBusiness(self.driver)
tmp.upgrade_system(PATH)
#设置PC的静态IP,能够访问DUT的webpage
tmp.set_eth_ip(data_basic['lan_pc'], data_basic['static_PC_ip'])
#关闭AP的eth1端口，以免她来分配ip地址，和桥接的dhcp server相冲突
tmp4 = WorkModeBusiness(self.driver)
tmp4.down_ap_eth1(data_basic['DUT_ip'], data_basic['ssh_user'],
data_basic['ssh_pwd'])
#刷新页面重新登录ap页面
Lg.refresh_login_ap()
tmp1 = StateInfoBusiness(self.driver)
#获取当前模式
result1 = tmp1.obtain_AP_current_mode()
#获取桥接的连接状态
result2 = tmp1.obtain_WAN_IP_generation()
#获取信号强度
result3 = tmp1.obtain_WAN_IP_address()
#判断ssid是否恢复
tmp2 = WirelessSettingsBusiness(self.driver)
result4 = tmp2.get_first_ssid(data_basic['DUT_ip'],
data_basic['ssh_user'],
data_basic['ssh_pwd'])
#登录ap后台，判断ap的工作模式
tmp3 = WorkModeBusiness(self.driver)
result5 = tmp3.check_DUT_workmode(data_basic['DUT_ip'],
data_basic['ssh_user'],
data_basic['ssh_pwd'])
#检查固件版本
result6 = tmp.check_system_version(data_basic['old_version'])
self.assertEqual(result1, "网桥模式")
self.assertEqual(result2, "已连接")
self.assertIn("dBm", result3)
self.assertIn(data_wirless['all_ssid'], result4)
self.assertIn("wds", result5)
self.assertTrue(result6)
log.debug("007\t\tpass")
def change_workmode_to_client_LANDHCP(self,
bridge_essid, bridge_encryption_mode,bridge_bssid,
bridge_pwd, user, pwd):
"""
修改工作模式为client模式,内网设置动态获取
"""
for i in range(3):
#点击工作模式菜单
self.menu_workmode()
#选择桥接模式
self.set_mode("client")
time.sleep(10)
#内网设置点击点击动态获取按钮
self.set_client_LAN_dhcp()
#点击下一步
self.click_next_button()
#桥接设置
# #点击扫描
# self.click_bridge_bridge_scan_button()
# time.sleep(10)
# #扫描页面中，根据扫描到的ap的mac地址点击对应的操作按钮
# self.set_bridge_bridge_scan_operat(bridge_bssid)
#桥接设置输入要桥接的ssid
self.set_client_bridge_ssid(bridge_essid)
#桥接设置要桥接的无线的加密方式
self.set_client_bridge_encryption(bridge_encryption_mode)
#输入桥接ap的无线密码
self.set_client_bridge_password(bridge_pwd)
#桥接设置要桥接的对端无线mac地址
self.set_client_bridge_BSSID(bridge_bssid)
#点击下一步
self.click_next_button()
#点击完成
self.click_finish_button()
time.sleep(5)
if self.check_waitbar_displayed():
time.sleep(85)
break
else:
Lg = LoginBusiness(self.driver)
#刷新页面重新登录ap页面
Lg.refresh_login_ap()
#设置PC的静态IP和桥接的路由的IP端一致
self.dhcp_release_wlan(data_basic['lan_pc'])
self.set_eth_ip(data_basic['lan_pc'], data_wireless['bridge_static_ip'])
#非路由模式下，获取ap的当前ip地址
ap_ip = self.get_ap_ip(data_wireless['bridge_ip'], data_basic['ssh_user'],
data_basic['ssh_pwd'], data_basic['ap_brlan_mac'])
#关闭AP的eth1端口，以免她来分配ip地址，和桥接的dhcp server相冲突
self.down_ap_eth1(ap_ip, user, pwd)
print("set bridge mode successfull!")
return ap_ip
def test_005_apmode_system_downgrade_check_config(self):
"""ap模式下，修改配置后，系统降级，检查配置"""
tmp1 = WorkModeBusiness(self.driver)
#设置PC的静态IP,能够访问DUT的webpage
tmp1.set_eth_ip(data_basic['lan_pc'], data_basic['static_PC_ip'])
#修改工作模式为AP模式,内网设置静态IP
tmp1.change_workmode_to_ap_LANstaticIP(data_basic['DUT_ip'],
data_lan['netmask1'],
data_wirless['all_ssid'],
"psk2",
data_wirless['short_wpa'],
"HT20")
time.sleep(30)
#逻辑类对象，建一个实例
Lg = LoginBusiness(self.driver)
#刷新页面重新登录ap页面
Lg.refresh_login_ap()
#选择固件路径，降级固件
PATH = os.path.join(
os.getcwd(), AP_model + '-' + data_basic['old_version'] + '.bin')
print(PATH)
tmp = SystemUpgradeBusiness(self.driver)
tmp.upgrade_system(PATH)
#设置PC的静态IP,能够访问DUT的webpage
tmp.set_eth_ip(data_basic['lan_pc'], data_basic['static_PC_ip'])
#刷新页面重新登录ap页面
Lg.refresh_login_ap()
tmp1 = StateInfoBusiness(self.driver)
#获取当前模式
result1 = tmp1.obtain_AP_current_mode()
#获取内网IP获取方式
result2 = tmp1.obtain_WAN_IP_generation()
#获取IP地址
result3 = tmp1.obtain_WAN_IP_address()
#判断ssid是否恢复
tmp2 = WirelessSettingsBusiness(self.driver)
result4 = tmp2.get_first_ssid(data_basic['DUT_ip'],
data_basic['ssh_user'],
data_basic['ssh_pwd'])
#登录ap后台，判断ap的工作模式
tmp3 = WorkModeBusiness(self.driver)
result5 = tmp3.check_DUT_workmode(data_basic['DUT_ip'],
data_basic['ssh_user'],
data_basic['ssh_pwd'])
#检查固件版本
result6 = tmp.check_system_version(data_basic['old_version'])
self.assertEqual(result1, "AP模式")
self.assertEqual(result2, "静态IP")
self.assertEqual(data_basic['DUT_ip'], result3)
self.assertIn(data_wirless['all_ssid'], result4)
self.assertIn("ap", result5)
self.assertTrue(result6)
log.debug("005\t\tpass")
def setUp(self):
self.driver = webdriver.Firefox()
self.driver.maximize_window()
self.driver.get(data_basic['DUT_web'])
self.driver.implicitly_wait(20)
#逻辑类对象，建一个实例
Lg = LoginBusiness(self.driver)
#调用实例的登录AP的web界面
Lg.login(data_basic['superUser'], data_basic['super_defalut_pwd'])
#刷新页面重新登录ap页面
Lg.refresh_login_ap()
def test_010_clientmode_system_upgrade_check_config(self):
"""客户端模式下，系统升级，检查配置"""
tmp = SystemUpgradeBusiness(self.driver)
#选择固件路径，升级固件
PATH = os.path.join(
os.getcwd(), AP_model + '-' + data_basic['new_version'] + '.bin')
print(PATH)
tmp.upgrade_system(PATH)
#设置PC的静态IP,能够访问DUT的webpage
tmp.set_eth_ip(data_basic['lan_pc'], data_basic['static_PC_ip'])
#关闭AP的eth1端口，以免她来分配ip地址，和桥接的dhcp server相冲突
tmp4 = WorkModeBusiness(self.driver)
tmp4.down_ap_eth1(data_basic['DUT_ip'], data_basic['ssh_user'],
data_basic['ssh_pwd'])
#逻辑类对象，建一个实例
Lg = LoginBusiness(self.driver)
#刷新页面重新登录ap页面
Lg.refresh_login_ap()
tmp1 = StateInfoBusiness(self.driver)
#获取当前模式
result1 = tmp1.obtain_AP_current_mode()
#获取桥接的连接状态
result2 = tmp1.obtain_WAN_IP_generation()
#获取信号强度
result3 = tmp1.obtain_WAN_IP_address()
#登录ap后台，判断ap的工作模式
tmp3 = WorkModeBusiness(self.driver)
result5 = tmp3.check_DUT_workmode(data_basic['DUT_ip'],
data_basic['ssh_user'],
data_basic['ssh_pwd'])
#检查固件版本
result6 = tmp.check_system_version(data_basic['new_version'])
#修改工作模式为路由模式,外网设置dhcp模式
tmp4.change_workmode_to_route_WANdhcp(data_wirless['all_ssid'], "psk2",
data_wirless['short_wpa'],
"HT40", "auto")
#client重新获取ip
tmp.dhcp_release_wlan(data_basic['lan_pc'])
tmp.dhcp_wlan(data_basic['lan_pc'])
tmp.disconnect_ap()
#删除下载固件
os.unlink(PATH)
self.assertEqual(result1, "客户端模式")
self.assertEqual(result2, "已连接")
self.assertIn("dBm", result3)
self.assertIn("wds_c", result5)
self.assertTrue(result6)
log.debug("010\t\tpass")
def check_wifi_upload(self, ssid, password, wlan, lan):
#AP 上传流量-50M
self.run_AP_upload_50M(ssid, password, wlan, lan)
#等待30s，刷新页面
time.sleep(30)
Lg = LoginBusiness(self.driver)
Lg.refresh_login_ap()
#取出WIFI总上行
value, unit = self.obtain_wifi_upload()
if unit == "MB":
if int(value) >= 50:
return True
return False
def get_bannedclients_title(self):
#刷新页面重新登录ap页面
Lg = LoginBusiness(self.driver)
Lg.refresh_login_ap()
#点击客户端菜单
tmp = ClientsBusiness(self.driver)
tmp.clients_menu()
#点击时间策略菜单
BannedClientsControl.bannedclients_menu(self)
#获取页面所有标题
result = BannedClientsControl.get_titlediv(self)
print result
return result
def change_workmode_to_ap_LANstaticIP(self, ip, netmask, ssid, encryption_mode,
password, width):
"""
修改工作模式为ap模式,内网设置静态IP
"""
for i in range(3):
#点击工作模式菜单
self.menu_workmode()
#选择ap模式
self.set_mode("ap")
time.sleep(10)
#内网设置点击静态IP按钮
self.set_AP_LAN_staticIP()
#输入静态IP的ip地址
self.set_AP_LAN_staticIP_ip(ip)
#输入静态IP的子网掩码
self.set_AP_LAN_staticIP_netmask(netmask)
#输入静态ip的gateway
self.set_AP_LAN_staticIP_gateway("")
#点击下一步
self.click_next_button()
# #防止AP模式下有时候点击下一步没有后跳到无线配置页面，判断web页面上是否有AP模式下的静态IP的元素
# for i in range(3):
# if not self.check_AP_LAN_staticIP_in_webpage():
# #再次点击下一步
# self.click_next_button()
# else:
# break
#无线设置
self.set_AP_24g_ssid(ssid)
self.set_AP_24g_encryption(encryption_mode)
self.set_AP_24g_password(password)
self.set_AP_24g_bandwidth(width)
#点击下一步
self.click_next_button()
#点击完成
self.click_finish_button()
time.sleep(5)
if self.check_waitbar_displayed():
time.sleep(85)
break
else:
Lg = LoginBusiness(self.driver)
#刷新页面重新登录ap页面
Lg.refresh_login_ap()
#指定有线网卡的固定ip--能够访问ap的webpage
self.dhcp_release_wlan(data_basic['lan_pc'])
self.set_eth_ip(data_basic['lan_pc'], data_basic['static_PC_ip'])
print("set ap mode successfull!")
def test_011_bridgemode_upload_config_file(self):
"""桥接模式下验证上传配置文件"""
tmp = ConfigUpdateBusiness(self.driver)
#文件路径
PATH = os.path.join(os.getcwd(), "bakup.file")
print(PATH)
#上传配置文件
tmp.upload_config_file(PATH)
#设置PC的静态IP,能够访问DUT的webpage
tmp.set_eth_ip(data_basic['lan_pc'], data_basic['static_PC_ip'])
#关闭AP的eth1端口，以免她来分配ip地址，和桥接的dhcp server相冲突
tmp4 = WorkModeBusiness(self.driver)
tmp4.down_ap_eth1(data_basic['DUT_ip'], data_basic['ssh_user'],
data_basic['ssh_pwd'])
#逻辑类对象，建一个实例
Lg = LoginBusiness(self.driver)
#刷新页面重新登录ap页面
Lg.refresh_login_ap()
tmp1 = StateInfoBusiness(self.driver)
#获取当前模式
result1 = tmp1.obtain_AP_current_mode()
#获取桥接的连接状态
result2 = tmp1.obtain_WAN_IP_generation()
#获取信号强度
result3 = tmp1.obtain_WAN_IP_address()
#判断ssid是否恢复
tmp2 = WirelessSettingsBusiness(self.driver)
result4 = tmp2.get_first_ssid(data_basic['DUT_ip'], data_basic['ssh_user'],
data_basic['ssh_pwd'])
#登录ap后台，判断ap的工作模式
tmp3 = WorkModeBusiness(self.driver)
result5 = tmp3.check_DUT_workmode(data_basic['DUT_ip'], data_basic['ssh_user'],
data_basic['ssh_pwd'])
#测试完成后删除备份文件
if result1 != "网桥模式":
#如果恢复配置失败，保存配置文件
dirname = os.path.dirname(os.path.dirname(__file__))
current_time = time.strftime('%m%d%H%M',time.localtime(time.time()))
backfile_PATH = os.path.join(dirname, "data", "testresultdata", "bridgemode_{}_bakup.file".format(current_time))
shutil.copy(PATH, backfile_PATH)
os.unlink(PATH)
self.assertEqual(result1, "网桥模式")
self.assertEqual(result2, "已连接")
self.assertIn("dBm", result3)
self.assertIn(data_wirless['all_ssid'], result4)
self.assertIn("wds", result5)
log.debug("011\t\tpass")
def setUp(self):
fp = webdriver.FirefoxProfile()
fp.set_preference("browser.download.folderList",2)
fp.set_preference("browser.download.manager.showWhenStarting",False)
fp.set_preference("browser.download.dir", os.getcwd())
fp.set_preference("browser.helperApps.neverAsk.saveToDisk","application/x-targz")
self.driver = webdriver.Firefox(firefox_profile=fp)
self.driver.maximize_window()
self.driver.get(data_basic['DUT_web'])
self.driver.implicitly_wait(20)
#逻辑类对象，建一个实例
Lg = LoginBusiness(self.driver)
#调用实例的登录AP的web界面
Lg.login(data_basic['superUser'], data_basic['super_defalut_pwd'])
#刷新页面重新登录ap页面
Lg.refresh_login_ap()
def check_AP_wireless_client(self,
ssid,
wlan,
wifi_encryption,
password=None):
#使用无线网卡连接ap
self.client_connect_ssid(ssid, wlan, wifi_encryption, password)
#等待30s，刷新页面
time.sleep(30)
Lg = LoginBusiness(self.driver)
Lg.refresh_login_ap()
#获取无线用户数
result = self.obtain_AP_wireless_client()
#无线网卡断开连接
self.disconnect_ap()
return result
def test_003_routemode_system_downgrade_check_config(self):
"""路由模式下，修改配置后，系统降级，检查配置"""
#修改工作模式为路由模式,外网设置static IP模式
tmp1 = WorkModeBusiness(self.driver)
tmp1.change_workmode_to_route_WANstaticIP(
data_wan['static_IP'], data_wan['netmask'], data_wan['gateway'],
data_wan['DNS'], data_wirless['all_ssid'], "psk2",
data_wirless['short_wpa'], "HT20", "auto")
time.sleep(60)
#逻辑类对象，建一个实例
Lg = LoginBusiness(self.driver)
#刷新页面重新登录ap页面
Lg.refresh_login_ap()
#选择固件路径，降级固件
PATH = os.path.join(
os.getcwd(), AP_model + '-' + data_basic['old_version'] + '.bin')
print(PATH)
tmp = SystemUpgradeBusiness(self.driver)
tmp.upgrade_system(PATH)
#刷新页面重新登录ap页面
Lg.refresh_login_ap()
tmp1 = StateInfoBusiness(self.driver)
#获取当前模式
result1 = tmp1.obtain_AP_current_mode()
#获取外网的IP获取方式
result2 = tmp1.obtain_WAN_IP_generation()
#获取IP地址
result3 = tmp1.obtain_WAN_IP_address()
#判断ssid是否恢复
tmp2 = WirelessSettingsBusiness(self.driver)
result4 = tmp2.get_first_ssid(data_basic['DUT_ip'],
data_basic['ssh_user'],
data_basic['ssh_pwd'])
#判断wan口是否是静态IP
tmp3 = WanSettingsBusiness(self.driver)
result5 = tmp3.get_wan_way(data_basic['DUT_ip'],
data_basic['ssh_user'],
data_basic['ssh_pwd'])
#检查固件版本
result6 = tmp.check_system_version(data_basic['old_version'])
self.assertEqual(result1, "路由模式")
self.assertEqual(result2, "静态IP")
self.assertEqual(data_wan['static_IP'], result3)
self.assertIn(data_wirless['all_ssid'], result4)
self.assertIn("static", result5)
self.assertTrue(result6)
log.debug("003\t\tpass")