def switch_user(self, user_mode):
'''
:param: user_mode: e.g. 'admin' or 'user'
'''
result = False
if user_mode == 'admin':
result = common_function.SwitchThinProMode('admin')
elif user_mode == 'user':
result = common_function.SwitchThinProMode('user')
else:
self.log.info('invalid user_mode {}'.format(user_mode))
return result
def set_eth0_speed(ethernet_speed):
try:
cf.SwitchThinProMode("admin")
wired = network_setting.Wired()
wired.open_network_wired_dialog()
wired.set_ethernet_speed(speed=ethernet_speed)
wired.apply()
log.info("close control panel")
wired.close_control_panel()
time.sleep(1)
s = subprocess.getoutput(
"mclient --quiet get root/Network/Wired/EthernetSpeed")
if s == ethernet_speed:
log.info(
"set 'Ethernet Speed' is '{}' success".format(ethernet_speed))
return True
else:
log.error(
"set 'Ethernet Speed' is '{}' fail".format(ethernet_speed))
return False
except:
log.error(traceback.format_exc())
pyautogui.screenshot(
cf.get_current_dir(
"Test_Report/check_speed_{}.png".format(ethernet_speed)))
return False
def step_2_2():
log.info("start check wireless after reboot")
cf.SwitchThinProMode("admin")
wireless = network_setting.Wireless()
for i in range(24):
log.info("wait connect wireless...")
time.sleep(5)
if wireless.check_wireless_connected():
log.info("wireless is connected")
break
else:
log.error("connect wireless time out")
return [False, "connect wireless time out"]
if not wait_element(pic("_systray_connect")):
log.error("not found the wireless systray icon")
pyautogui.screenshot(
cf.get_current_dir(
"Test_Report/ssid_disable_and_enable_wireless_error.png"))
return [False, "not found the wireless systray icon"]
log.info("found the wireless systray icon")
wireless.open_network()
wireless.switch_to_wireless_tab()
if not wait_element(pic("_black_add_gray_edit_del"), rate=0.99):
log.error("not found the black add and edit delete")
return [False, "not found the black add and edit delete"]
log.info("found the black add and edit delete")
wireless.close_control_panel()
restore()
# log.info("{:+^80}".format("test case pass"))
return [True, "success"]
def userlock_is_1(**kwargs):
report_file = kwargs.get("report_file")
case_name = kwargs.get("case_name")
hostname = get_default_hostname()
log.info("{:-^80}".format("start a case test"))
log.info("case name:" + case_name)
cf.SwitchThinProMode("admin")
modify_hostname_registry("asdfgh")
wired = network_setting.Wired()
wired_connection_mode = subprocess.getoutput(
"mclient --quiet get root/Network/Wired/Method")
if wired_connection_mode is not "Automatic":
subprocess.call(
"mclient --quiet set root/Network/Wired/Method 'Automatic'",
shell=True)
subprocess.call("mclient commit", shell=True)
for i in range(20):
log.info("wait connect network...")
time.sleep(2)
if wired.check_wired_is_connected():
log.info("wired is connected")
break
set_userlock("1")
export_profile()
if not set_static_network():
log.error("set static network error")
report = {
'step_name': 'set static network',
'result': 'fail',
'expect': "set static network success",
'actual': "set static network fail",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
teardown_test_environment()
modify_hostname_registry(hostname)
cf.import_profile()
os.remove(cf.get_current_dir("Test_Data/profile_file.xml"))
log.error("{:+^80}".format("test case fail"))
return False
import_profile()
log.info("reboot")
time.sleep(30)
def step_1_2(**kwargs):
case_name = kwargs.get("case_name")
report_file = kwargs.get("report_file")
ssid = kwargs.get("ssid")
log.info("{:-^80}".format("start a case test"))
log.info("case name:" + case_name)
cf.SwitchThinProMode("admin")
wireless = network_setting.Wireless()
wireless.close_control_panel()
if not wireless.check_wireless_card():
try:
wireless.restore_wireless()
except Exception as e:
log.error(traceback.print_exc())
traceback.print_exc()
raise e
finally:
wireless.close_control_panel()
time.sleep(3)
if not wireless.check_wireless_card():
log.error("not found the wireless card on thin client")
report = {
'step_name': 'check wireless card',
'result': 'fail',
'expect': "thin client has wireless card",
'actual': "not found wireless card on thin client",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
log.error("{:+^80}".format("test case fail"))
wireless.restore_wireless()
return False
ssid_list = [
"R1-Linux-5N_thinpro_store", "R1-Linux-5N_ssl_store", "R1-Linux-AC"
]
if ssid in ssid_list: # import ROOTCA.cer
if not cf.import_cert():
log.error("import cert fail")
report = {
'step_name': 'import cert',
'result': 'fail',
'expect': "import cert success",
'actual': "import cert fail",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
log.error("{:+^80}".format("test case fail"))
wireless.restore_wireless()
return False
if ssid == "R1-Linux-2.4N":
folder = subprocess.getoutput("ls /media")
rootca_path = os.path.join("/media", folder, "Certs", "ROOTCA.cer")
cert_8021x = os.path.join("/media", folder, "Certs", "802.1X.pfx")
if not os.path.exists(rootca_path) or not os.path.exists(cert_8021x):
log.error(
"not found the cert 'ROOTCA.cer' or '802.1X.pfx' in /media/{}/Certs"
.format(format(folder)))
report = {
'step_name': "check cert 'ROOTCA.cer' and '802.1X.pfx'",
'result': 'fail',
'expect': "found 'ROOTCA.cer' and '802.1X.pfx' in USB store",
'actual':
"not found the cert 'ROOTCA.cer' or '802.1X.pfx' in /media/.../Certs",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
log.error("{:+^80}".format("test case fail"))
wireless.restore_wireless()
return False
wired = network_setting.Wired()
if wired.check_wired_is_connected():
wired.set_wired_and_wireless_simultaneously()
wired.disable_eth0()
wireless.del_wireless_profile_from_reg()
con_res = connect_wireless(wireless=wireless, ssid=ssid)
if con_res is False or con_res: # connect wireless
log.error("add wireless {} profile fail".format(ssid))
wireless.close_control_panel()
wireless.del_wireless_profile_from_reg()
wired.set_wired_connection_priority()
if not wired.check_wired_is_connected():
wired.enable_eth0()
log.info("wait connect wired")
time.sleep(10)
report = {
'step_name': 'add wireless ' + ssid + ' profile fail',
'result': 'fail',
'expect': "connect wireless success",
'actual': "connect wireless fail, time out",
'note': f'{con_res}'
}
cf.update_cases_result(report_file, case_name, report)
wireless.restore_wireless()
return False
for i in range(24):
log.info("wait connect wireless {}...".format(ssid))
time.sleep(5)
if wireless.check_wireless_connected():
log.info("wireless connect success")
break
else:
log.error("connect wireless time out")
report = {
'step_name': 'connect wireless',
'result': 'fail',
'expect': "connect wireless success",
'actual': "connect wireless fail, time out",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
wireless.del_wireless_profile_from_reg()
wired.set_wired_connection_priority()
wired.enable_eth0()
log.error("{:+^80}".format("test case fail"))
wireless.restore_wireless()
return False
report = {
'step_name': 'connect wireless',
'result': 'Pass',
'expect': "connect wireless success",
'actual': "connect wireless success",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
log.info('Wait 30 seconds to stabilize the network')
time.sleep(30)
if not network.ping_server(ip="15.83.240.98"): # ping 15.83.240.98
report = {
'step_name': 'ping "15.83.240.98"',
'result': 'fail',
'expect': "ping server success",
'actual': "ping server fail",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
wireless.del_wireless_profile_from_reg()
wired.set_wired_connection_priority()
wired.enable_eth0()
log.error("{:+^80}".format("test case fail"))
wireless.restore_wireless()
return False
report = {
'step_name': 'ping "15.83.240.98"',
'result': 'pass',
'expect': "ping server success",
'actual': "ping server success",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
log.info("start reboot")
os.system("reboot")
time.sleep(60)
def step_3_4(**kwargs):
case_name = kwargs.get("case_name")
report_file = kwargs.get("report_file")
ssid = kwargs.get("ssid")
log.info("check wireless status after reboot")
cf.SwitchThinProMode("admin")
wireless = network_setting.Wireless()
wired = network_setting.Wired()
for i in range(24):
if wireless.check_wireless_connected():
log.info("wireless auto connect success after reboot")
break
log.info("wait connect wireless {}...".format(ssid))
time.sleep(5)
else:
log.error("connect wireless time out")
report = {
'step_name': 'check wireless status',
'result': 'fail',
'expect': "wireless auto connect success after reboot",
'actual': "wireless auto connect fail after reboot",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
wireless.del_wireless_profile_from_reg()
wired.set_wired_connection_priority()
wired.enable_eth0()
log.error("{:+^80}".format("test case fail"))
wireless.restore_wireless()
return False
report = {
'step_name': 'check wireless status',
'result': 'pass',
'expect': "wireless auto connect success after reboot",
'actual': "wireless auto connect success after reboot",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
log.info("start delete the wireless profile")
wireless.del_wireless_profile_from_reg()
log.info("wait wireless disconnect")
time.sleep(10)
if wireless.check_wireless_connected():
log.error("wireless connected")
report = {
'step_name': 'check wireless status',
'result': 'fail',
'expect': "wireless is disconnect after delete wireless profile",
'actual': "wireless is connect after delete wireless profile",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
wired.set_wired_connection_priority()
wired.enable_eth0()
log.error("{:+^80}".format("test case fail"))
wireless.restore_wireless()
return False
report = {
'step_name': 'check wireless status',
'result': 'pass',
'expect': "wireless is disconnect after delete wireless profile",
'actual': "wireless is disconnect after delete wireless profile",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
wired.set_wired_connection_priority()
if not wired.check_wired_is_connected():
log.info("wired is not connected")
wired.enable_eth0()
time.sleep(20)
log.info("{:+^80}".format("test case pass"))
return True
def __init__(self, protocol_name, bypass_setting=False):
self.protocol = protocol_name
self.bypass_setting = bypass_setting
self.dns = network_setting.DNS()
self.tp = common_function.SwitchThinProMode('admin')
def start(case_name, **kwargs):
log = Logger()
log.info("{:-^80}".format("start a case test"))
log.info("case name:" + case_name)
report_file = os.path.join(cf.get_current_dir(), "Test_Report",
"{}.yaml".format(cf.check_ip_yaml()))
cf.new_cases_result(report_file, case_name)
session = "win10"
root_password = '******'
user_password = '******'
time.sleep(0.5)
log.info(" -------------------------------------------step 1")
if not step_1(log=log):
step1_report = {
'step_name': 'step1',
'result': 'Fail',
'expect': 'set screen saver default success',
'actual': 'set screen saver default fail',
'note': ''
}
cf.update_cases_result(report_file, case_name, step1_report)
cf.SwitchThinProMode("admin")
log.error("{:+^80}".format("test case fail"))
return False
step1_report = {
'step_name': 'step1',
'result': 'Pass',
'expect': 'set screen saver default and switch to user success',
'actual': 'set screen saver default and switch to user success',
'note': ''
}
cf.update_cases_result(report_file, case_name, step1_report)
log.info(" -------------------------------------------step 2")
result_2 = step_2(log=log, case_name=case_name)
if not result_2[0]:
step2_report = {
'step_name': 'step2',
'result': 'Fail',
'expect': 'no need to input any accounts to unlock the screen',
'actual': 'fail',
'note': '{}'.format(result_2[1])
}
cf.update_cases_result(report_file, case_name, step2_report)
log.error("{:+^80}".format("test case fail"))
cf.SwitchThinProMode("admin")
return False
step2_report = {
'step_name': 'step2',
'result': 'pass',
'expect': 'no need to input any accounts to unlock the screen',
'actual': 'success',
'note': '{}'.format(result_2[1])
}
cf.update_cases_result(report_file, case_name, step2_report)
log.info(" ---------------------------------------------step 3_4")
result_3_4 = step_3_4(log=log, case_name=case_name)
if not result_3_4[0]:
step4_report = {
'step_name': 'step 3_4',
'result': 'Fail',
'expect': 'screen can be unlock by the credentals',
'actual': 'fail',
'note': '{}'.format(result_3_4[1])
}
cf.update_cases_result(report_file, case_name, step4_report)
cf.SwitchThinProMode("admin")
log.error("{:+^80}".format("test case fail"))
return False
step4_report = {
'step_name': 'step 3_4',
'result': 'pass',
'expect': 'screen can be unlock by the credentals',
'actual': 'success',
'note': '{}'.format(result_3_4[1])
}
cf.update_cases_result(report_file, case_name, step4_report)
log.info(" -------------------------------------------step 5_6")
result_5_6 = step_5_6(log=log,
session=session,
root_password=root_password,
case_name=case_name)
if not result_5_6[0]:
step6_report = {
'step_name':
'step 5_6',
'result':
'fail',
'expect':
"'user' is not in the locked accounts, 'root' can not unlock the remote session,"
" screen can be unlock by the credentials",
'actual':
'fail',
'note':
'{}'.format(result_5_6[1])
}
cf.update_cases_result(report_file, case_name, step6_report)
cf.SwitchThinProMode("admin")
log.error("{:+^80}".format("test case fail"))
return False
step6_report = {
'step_name':
'step 5_6',
'result':
'pass',
'expect':
"'user' is not in the locked accounts, 'root' can not unlock the remote session,"
" screen can be unlock by the credentials",
'actual':
'success',
'note':
'{}'.format(result_5_6[1])
}
cf.update_cases_result(report_file, case_name, step6_report)
log.info("-------------------------------------------step 7_8")
result_7_8 = step_7_8(log=log,
user_password=user_password,
case_name=case_name)
if not result_7_8[0]:
step8_report = {
'step_name': 'step 7_8',
'result': 'fail',
'expect': "'user' account can unlock the screen",
'actual': 'fail',
'note': '{}'.format(result_7_8[1])
}
cf.update_cases_result(report_file, case_name, step8_report)
os.system("mclient --quiet set root/screensaver/lockScreenUser 0"
) # disable require password for general users
os.system("mclient commit")
cf.SwitchThinProMode("admin")
log.error("{:+^80}".format("test case fail"))
return False
step8_report = {
'step_name': 'step 7_8',
'result': 'pass',
'expect': "'user' account can unlock the screen",
'actual': 'success',
'note': '{}'.format(result_7_8[1])
}
cf.update_cases_result(report_file, case_name, step8_report)
log.info(" ------------------------------------------- step 9")
result_9 = step_9(log=log,
user_password=user_password,
case_name=case_name)
if not result_9[0]:
step9_report = {
'step_name': 'step9',
'result': 'fail',
'expect':
"both 'user' and the login account can unlock the screen",
'actual': 'fail',
'note': '{}'.format(result_9[1])
}
cf.update_cases_result(report_file, case_name, step9_report)
os.system("mclient --quiet set root/screensaver/lockScreenUser 0"
) # disable require password for general users
os.system("mclient commit")
cf.SwitchThinProMode("admin")
log.error("{:+^80}".format("test case fail"))
return False
step9_report = {
'step_name': 'step9',
'result': 'pass',
'expect': "both 'user' and the login account can unlock the screen",
'actual': 'success',
'note': '{}'.format(result_9[1])
}
cf.update_cases_result(report_file, case_name, step9_report)
os.system("mclient --quiet set root/screensaver/lockScreenUser 0"
) # disable require password for general users
os.system("mclient commit")
log.info("test case pass")
cf.SwitchThinProMode("admin")
log.info("{:+^80}".format("this case test over"))
return True
def start(case_name, **kwargs):
log = Logger()
log.info("{:-^80}".format("start a case test"))
log.info("case name:" + case_name)
report_file = os.path.join(cf.get_current_dir(), "Test_Report", "{}.yaml".format(cf.check_ip_yaml()))
cf.new_cases_result(report_file, case_name)
time.sleep(0.5)
platform = subprocess.getoutput("hptc-hwsw-id --hw")
if "mt" not in platform:
log.error("dtc can't run this case")
step1 = {'step_name': 'check current platform',
'result': 'Fail',
'expect': '',
'actual': '',
'note': 'current platform is not mtc, skip the case'}
cf.update_cases_result(report_file, case_name, step1)
log.info("{:+^70}".format("this case test over"))
time.sleep(1)
return False
cf.SwitchThinProMode(switch_to="user")
time.sleep(2)
if not power_manager_factory.PowerManager.open_power_manager_from_tray():
step1 = {'step_name': 'step1',
'result': 'Fail',
'expect': 'in user mode, open the power manager from the system tray success',
'actual': 'open the power manager from the system tray fail',
'note': ''}
cf.update_cases_result(report_file, case_name, step1)
log.info("{:+^70}".format("this case test over"))
time.sleep(1)
return False
step1 = {'step_name': 'step1',
'result': 'Pass',
'expect': 'in user mode, open the power manager from the system tray success',
'actual': 'open the power manager from the system tray success',
'note': ''}
cf.update_cases_result(report_file, case_name, step1)
os.system("wmctrl -c 'Control Panel'")
time.sleep(1)
cf.SwitchThinProMode(switch_to="admin")
time.sleep(2)
if not power_manager_factory.PowerManager.open_power_manager_from_tray():
step2 = {'step_name': 'step2',
'result': 'Fail',
'expect': 'in admin mode, open the power manager from the system tray success',
'actual': 'open the power manager from the system tray fail',
'note': ''}
cf.update_cases_result(report_file, case_name, step2)
log.info("{:+^70}".format("this case test over"))
time.sleep(1)
return False
step2 = {'step_name': 'step2',
'result': 'Pass',
'expect': 'in admin mode, open the power manager from the system tray success',
'actual': 'open the power manager from the system tray success',
'note': ''}
cf.update_cases_result(report_file, case_name, step2)
time.sleep(1)
os.system("wmctrl -c 'Control Panel'") # close control panel
log.info("{:+^70}".format("this case test over"))
time.sleep(1)
return True
def userlock_is_0_after_reboot(**kwargs):
report_file = kwargs.get("report_file")
case_name = kwargs.get("case_name")
hostname = get_default_hostname()
cf.SwitchThinProMode("admin")
if get_hostname_registry() != "asdfgh":
log.error("hostname not is 'asdfgh'")
report = {
'step_name': 'check hostname after import profile',
'result': 'fail',
'expect': "hostname is 'asdfgh'",
'actual': "hostname not is 'asdfgh'",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
cf.import_profile()
teardown_test_environment()
modify_hostname_registry(hostname)
os.remove(cf.get_current_dir("Test_Data/profile_file.xml"))
log.error("{:+^80}".format("test case fail"))
return False
log.info("hostname is 'asdfgh'")
report = {
'step_name': 'check hostname after import profile',
'result': 'pass',
'expect': "hostname is 'asdfgh'",
'actual': "hostname is 'asdfgh'",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
connection_mode = subprocess.getoutput(
"mclient --quiet get root/Network/Wired/Method")
ip_list = get_static_network_value()
if connection_mode == "Static" or ip_list.count(
"") != 3: # check mode and static ip
log.error(
"the network setting of profile not restore after import profile")
final_report = {
'step_name': 'userLock is 0 and after import profile',
'result': 'fail',
'expect':
"network connection mode is 'Automatic', and clear static ip",
'actual':
"network connection mode not is 'Automatic', or not clear static ip",
'note': ''
}
cf.update_cases_result(report_file, case_name, final_report)
cf.import_profile()
teardown_test_environment()
modify_hostname_registry(hostname)
os.remove(cf.get_current_dir("Test_Data/profile_file.xml"))
log.error("{:+^80}".format("test case fail"))
return False
log.info("the network setting of profile has restore after import profile")
final_report = {
'step_name': 'userLock is 0 and after import profile',
'result': 'Pass',
'expect':
"network connection mode is 'Automatic', and clear static ip",
'actual':
"network connection mode is 'Automatic', and clear static ip",
'note': ''
}
cf.update_cases_result(report_file, case_name, final_report)
cf.import_profile()
modify_hostname_registry(hostname)
os.remove(cf.get_current_dir("Test_Data/profile_file.xml"))
log.info("{:+^80}".format("test case pass"))
return True
def userlock_is_0(**kwargs):
report_file = kwargs.get("report_file")
case_name = kwargs.get("case_name")
hostname = get_default_hostname()
cf.SwitchThinProMode("admin")
if get_hostname_registry() != "asdfgh":
log.error("hostname not is 'asdfgh'")
report = {
'step_name': 'check hostname after import profile',
'result': 'fail',
'expect': "hostname is 'asdfgh'",
'actual': "hostname not is 'asdfgh'",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
teardown_test_environment()
modify_hostname_registry(hostname)
cf.import_profile()
os.remove(cf.get_current_dir("Test_Data/profile_file.xml"))
log.error("{:+^80}".format("test case fail"))
return False
log.info("hostname is 'asdfgh'")
report = {
'step_name': 'check hostname after import profile',
'result': 'pass',
'expect': "hostname is 'asdfgh'",
'actual': "hostname is 'asdfgh'",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
connection_mode = subprocess.getoutput(
"mclient --quiet get root/Network/Wired/Method")
ip_list = get_static_network_value()
if connection_mode != "Static" or ip_list.count(
"") == 3: # check mode and static ip
log.error(
"connection mode and static ip info has modified after import profile"
)
report = {
'step_name': 'userLock is 1 and after import profile',
'result': 'fail',
'expect':
"check connection mode is static and static ip not has clear",
'actual':
"check connection mode not is static or static ip has clear",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
cf.import_profile()
teardown_test_environment()
modify_hostname_registry(hostname)
os.remove(cf.get_current_dir("Test_Data/profile_file.xml"))
log.error("{:+^80}".format("test case fail"))
return False
log.info(
"connection mode and static ip info not modified after import profile")
report = {
'step_name': 'userLock is 1 and after import profile',
'result': 'pass',
'expect':
"check connection mode is static and static ip not has clear",
'actual':
"check connection mode is static and static ip not has clear",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
log.info("set userLock=0 and test again") # set userLock = 0
teardown_test_environment()
set_userlock("0")
export_profile()
set_static_network()
wired = network_setting.Wired()
for i in range(20):
log.info("wait wired connect...")
time.sleep(2)
if wired.check_wired_is_connected():
log.info("wired is connected")
break
else:
log.error("connect wired time out")
report = {
'step_name': 'connect wired',
'result': 'fail',
'expect': "connect wired success after set static ip",
'actual': "connect wired time out",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
cf.import_profile()
teardown_test_environment()
modify_hostname_registry(hostname)
os.remove(cf.get_current_dir("Test_Data/profile_file.xml"))
log.error("{:+^80}".format("test case fail"))
return False
import_profile()
log.info("reboot")
time.sleep(30)
def step_1(**kwargs):
case_name = kwargs.get("case_name")
log.info("{:-^80}".format("start a case test"))
log.info("case name: " + case_name)
log.info("start prepare the pre_condition")
wireless = network_setting.Wireless() # check wireless card
if not wireless.check_wireless_card():
try:
restore_wireless()
except Exception as e:
log.error(traceback.print_exc())
traceback.print_exc()
finally:
wireless.close_control_panel()
time.sleep(3)
if not wireless.check_wireless_card():
log.error("not found wireless card on thin client")
return [
False,
"found wireless card but not found wlan0 on thin client"
]
wired = network_setting.Wired()
if wired.check_wired_is_connected():
log.info("wired is connected")
wired.set_wired_and_wireless_simultaneously()
wired.disable_eth0()
time.sleep(2)
wireless.del_wireless_profile_from_reg()
log.info("start connect wireless 'R1-TC_5G_n'")
cf.SwitchThinProMode("admin")
wireless.open_network()
wireless.switch_to_wireless_tab()
wireless.add(ssid="R1-TC_5G_n")
wireless.apply_and_ok()
wireless.apply()
wireless.close_control_panel()
for i in range(24):
log.info("wait connect wireless...")
time.sleep(5)
if wireless.check_wireless_connected():
log.info("wireless has connected")
break
else:
log.error("connect wireless time out")
wireless.set_wired_connection_priority()
wired.enable_eth0()
return [False, "connect wireless time out"]
log.info("start test case-----------------------------")
log.info("start disable wireless")
wireless.open_network()
wireless.switch_to_wireless_tab()
wireless.disable_wireless() # disable wireless
wireless.apply()
add_edit_del = wait_element(pic("_gray_add_edit_del"), rate=0.99)
if not add_edit_del:
log.error("add, edit, delete not is gray")
restore_wireless()
return [False, "add, edit, delete not is gray"]
log.info("add, edit, delete is gray")
wireless.close_control_panel()
if wireless.check_wireless_connected():
log.error("wireless is connected")
restore_wireless()
return [False, "wireless is connected"]
log.info("wireless is disconnected")
if wait_element(pic("_systray_not_connect")):
log.error("systray wireless icon is exist")
restore_wireless()
return [False, "systray wireless icon is exist"]
wlan0 = subprocess.getoutput("ifconfig | grep -i wlan0")
if wlan0:
log.error("found the 'wlan0' use command 'ifconfig'")
restore_wireless()
return [False, "found the 'wlan0' use command 'ifconfig'"]
log.info("systray wireless icon is not exist")
log.info("start reboot")
return [True, "step_1 test pass"]
def step_2_1():
log.info("start step-1_2------------------------")
cf.SwitchThinProMode("admin")
wireless = network_setting.Wireless()
log.info("start check whether wireless is connected after reboot")
if wireless.check_wireless_connected():
log.error("wireless is connected after reboot")
return [
False, "Known issues: At Condition(disable eth0) and Reboot, "
"you can find wlan0 in terminal use command: ifconfig"
]
log.info("wireless is disconnected after reboot")
log.info("start check wireless systray icon")
if wait_element(pic("_systray_not_connect")):
log.error("found the wireless systray icon")
return [False, "found the wireless systray icon"]
log.info("not found the wireless systray icon")
log.info("start check add, edit and delete button")
wireless.open_network()
wireless.switch_to_wireless_tab()
if not wait_element(pic("_gray_add_edit_del"), rate=0.99):
log.error("add, edit and delete button is not gray")
return [False, "add, edit and delete button is not gray"]
log.info("add, edit and delete button is gray")
log.info("start step 2-------------------------")
wireless.enable_wireless()
wireless.apply()
log.info("start check add, edit and delete button")
if not wait_element(pic("_black_add_gray_edit_del"), rate=0.99):
log.error("not found the black add and edit delete")
return [False, "not found the black add and edit delete"]
log.info("found the black add and edit delete")
wireless.close_control_panel()
for i in range(24):
log.info("wait connect wireless...")
time.sleep(5)
if wireless.check_wireless_connected():
log.info("wireless is connected")
break
else:
log.error("connect wireless time out")
return [False, "connect wireless time out"]
if not wait_element(pic("_systray_connect")):
log.warning("not found the wireless systray icon")
pyautogui.screenshot(
cf.get_current_dir(
"Test_Report/ssid_disable_and_enable_wireless_error.png"))
log.info("start check wireless use command and process")
wlan0 = subprocess.getoutput("ifconfig | grep -i wlan0")
if not wlan0:
log.info("not found the 'wlan0' use command 'ifconfig'")
return [
False,
"not found the wireless systray icon and the 'wlan0' use command 'ifconfig'"
]
log.info("found the wlan0 use ifconfig")
network_systray_icon_process = subprocess.getoutput(
"ps -ef | grep 'hptc-network-mgr-systray'")
if not network_systray_icon_process:
log.error("not found the 'hptc-network-mgr-systray' process")
return [
False,
"not found the wireless systray icon and 'hptc-network-mgr-systray' process"
]
log.info("found the 'hptc-network-mgr-systray' process")
log.info("found the wireless systray icon")
log.info("start reboot")
return [True, "step 2 success"]
def start(case_name, **kwargs):
ssid = kwargs.get("ssid", "R1-TC_2.4G_n_WPA2P")
report_file = os.path.join(cf.get_current_dir(), "Test_Report",
"{}.yaml".format(cf.check_ip_yaml()))
cf.new_cases_result(report_file, case_name)
log.info("{:-^80}".format("start a case test"))
log.info("case name:" + case_name)
wireless = network_setting.Wireless()
if not wireless.check_wireless_card():
log.error("not found the wireless card on thin client")
report = {
'step_name': 'check wireless card',
'result': 'fail',
'expect': "thin client has wireless card",
'actual': "not found wireless card on thin client",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
log.error("{:+^80}".format("test case fail"))
return False
cf.SwitchThinProMode("admin")
wireless.close_control_panel()
wired = network_setting.Wired()
if wired.check_wired_is_connected():
wired.set_wired_and_wireless_simultaneously()
wired.disable_eth0()
wireless.del_wireless_profile_from_reg()
if not connect_wireless(ssid=ssid): # connect wireless
log.error("add wireless {} profile fail".format(ssid))
wireless.close_control_panel()
wireless.del_wireless_profile_from_reg()
wired.set_wired_connection_priority()
if not wired.check_wired_is_connected():
wired.enable_eth0()
log.info("wait connect wired")
time.sleep(10)
report = {
'step_name': 'add wireless ' + ssid + ' profile fail',
'result': 'fail',
'expect': "connect wireless success",
'actual': "connect wireless fail, time out",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
return False
for i in range(24):
log.info("wait connect wireless...")
time.sleep(5)
if wireless.check_wireless_connected():
log.info("wireless connect success")
break
else:
log.error("connect wireless time out")
report = {
'step_name': 'connect wireless',
'result': 'fail',
'expect': "connect wireless success",
'actual': "connect wireless fail, time out",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
wireless.del_wireless_profile_from_reg()
wired.set_wired_connection_priority()
log.error("{:+^80}".format("test case fail"))
return False
report = {
'step_name': 'connect wireless',
'result': 'Pass',
'expect': "connect wireless success",
'actual': "connect wireless success",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
if not network.ping_server(ip="15.83.240.98"): # ping 15.83.240.98
report = {
'step_name': 'ping "15.83.240.98"',
'result': 'fail',
'expect': "ping server success",
'actual': "ping server fail",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
wireless.del_wireless_profile_from_reg()
wired.set_wired_connection_priority()
log.error("{:+^80}".format("test case fail"))
return False
report = {
'step_name': 'ping "15.83.240.98"',
'result': 'pass',
'expect': "ping server success",
'actual': "ping server success",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
log.info("set 'root/Network/disableLeftClickMenu' is 0")
for i in range(2):
os.system("mclient --quiet set root/Network/disableLeftClickMenu 0")
time.sleep(2)
os.system("mclient commit")
time.sleep(5)
disableLeftvalue = os.system(
"mclient --quiet get root/Network/disableLeftClickMenu")
if disableLeftvalue == 0:
log.info("disableLeftvalue edit successful")
break
else:
log.info("disableLeftvalue edit fail")
continue
time.sleep(1)
if not stop_network(): # stop network
report = {
'step_name': 'stop network',
'result': 'fail',
'expect': "stop network from network systray icon success",
'actual': "stop network from network systray icon fail",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
wireless.del_wireless_profile_from_reg()
wired.set_wired_connection_priority()
os.system("mclient --quiet set root/Network/disableLeftClickMenu 1")
os.system("mclient commit")
log.error("{:+^80}".format("test case fail"))
return False
report = {
'step_name': 'stop network',
'result': 'pass',
'expect': "stop network from network systray icon success",
'actual': "stop network from network systray icon success",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
if not start_network(): # start network
report = {
'step_name': 'start network',
'result': 'fail',
'expect': "start network from network systray icon success",
'actual': "start network from network systray icon fail",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
wireless.del_wireless_profile_from_reg()
wired.set_wired_connection_priority()
os.system("mclient --quiet set root/Network/disableLeftClickMenu 1")
os.system("mclient commit")
log.error("{:+^80}".format("test case fail"))
return False
report = {
'step_name': 'start network',
'result': 'pass',
'expect': "start network from network systray icon success",
'actual': "start network from network systray icon success",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
if not restart_network(): # start network
report = {
'step_name': 'restart network',
'result': 'fail',
'expect': "restart network from network systray icon success",
'actual': "restart network from network systray icon fail",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
wireless.del_wireless_profile_from_reg()
wired.set_wired_connection_priority()
os.system("mclient --quiet set root/Network/disableLeftClickMenu 1")
os.system("mclient commit")
log.error("{:+^80}".format("test case fail"))
return False
report = {
'step_name': 'restart network',
'result': 'pass',
'expect': "restart network from network systray icon success",
'actual': "restart network from network systray icon success",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
log.info("start delete the wireless profile")
wireless.del_wireless_profile_from_reg()
log.info("wait wireless disconnect")
time.sleep(10)
if wireless.check_wireless_connected():
log.error("wireless connected")
report = {
'step_name': 'check wireless status',
'result': 'fail',
'expect': "wireless is disconnect after delete wireless profile",
'actual': "wireless is connect after delete wireless profile",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
wired.set_wired_connection_priority()
os.system("mclient --quiet set root/Network/disableLeftClickMenu 1")
os.system("mclient commit")
log.error("{:+^80}".format("test case fail"))
return False
report = {
'step_name': 'check wireless status',
'result': 'pass',
'expect': "wireless is disconnect after delete wireless profile",
'actual': "wireless is disconnect after delete wireless profile",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
wired.set_wired_connection_priority()
os.system("mclient --quiet set root/Network/disableLeftClickMenu 1")
os.system("mclient commit")
if not wired.check_wired_is_connected():
log.info("wired is not connected")
wired.enable_eth0()
time.sleep(20)
log.info("{:+^80}".format("test case pass"))
return True
def start(case_name, **kwargs):
log.info("{:-^80}".format("start a case test"))
log.info("case name:" + case_name)
report_file = os.path.join(cf.get_current_dir(), "Test_Report",
"{}.yaml".format(cf.check_ip_yaml()))
cf.new_cases_result(report_file, case_name)
before = subprocess.getoutput(
"mclient --quiet get root/Network/userLockEngaged")
log.info("current userLockEngaged value {}".format(before))
wired = network_setting.Wired()
wireless = network_setting.Wireless()
if not wireless.check_wireless_card(): # check wireless card
log.error("not found the wireless card on thinpro")
pre_check_report = {
'step_name': 'pre_check',
'result': 'Fail',
'expect': 'ThinPro has wireless card',
'actual': 'not found the wireless card on thin client',
'note': ''
}
cf.update_cases_result(report_file, case_name, pre_check_report)
log.error("{:+^80}".format("test case fail"))
return False
wireless.del_wireless_profile_from_reg()
if wired.check_wired_is_connected(): # check wired connected
log.info("wired is connected")
wired.set_wired_and_wireless_simultaneously()
wired.disable_eth0()
time.sleep(3)
value = subprocess.getoutput(
"mclient --quiet get root/Network/EncryptWpaConfig"
) # step 1-------------
if int(value) != 1:
log.error("the default value of 'network/EncryptWpaConfig' not is '1'")
step_1_report = {
'step_name': 'check value of "root/Network/EncryptWpaConfig"',
'result': 'Fail',
'expect': 'the value of "root/Network/EncryptWpaConfig" is 1',
'actual': 'the value of "root/Network/EncryptWpaConfig" not is 1',
'note': ''
}
cf.update_cases_result(report_file, case_name, step_1_report)
wired.set_wired_connection_priority()
log.error("{:+^80}".format("test case fail"))
return False
log.info("the default value of 'network/EncryptWpaConfig' is '1'")
step_1_report = {
'step_name': 'check value of "root/Network/EncryptWpaConfig"',
'result': 'Pass',
'expect': 'the value of "root/Network/EncryptWpaConfig" is 1',
'actual': 'the value of "root/Network/EncryptWpaConfig" is 1',
'note': ''
}
cf.update_cases_result(report_file, case_name, step_1_report)
log.info("start connect a wireless ap") # step 2-------------
cf.SwitchThinProMode("admin")
wireless.open_network()
wireless.switch_to_wireless_tab()
wireless.add(ssid="R1-Linux-disconnect")
# wireless.add(ssid="R1-TC_5G_n")
wireless.apply_and_ok()
wireless.apply()
wireless.close_control_panel()
for i in range(12):
log.info("wait connect wireless...")
time.sleep(5)
if wireless.check_wireless_connected():
log.info("wireless connected success")
break
else:
log.error("connect wireless time out")
step_2_report = {
'step_name': 'connect wireless',
'result': 'Fail',
'expect': 'connect wireless success',
'actual': 'connect wireless fail',
'note': ''
}
cf.update_cases_result(report_file, case_name, step_2_report)
wireless.del_wireless_profile_from_reg()
wired.set_wired_connection_priority()
if not wired.check_wired_is_connected():
wired.enable_eth0()
log.error("{:+^80}".format("test case fail"))
return False
step_2_report = {
'step_name': 'connect wireless',
'result': 'Pass',
'expect': 'connect wireless success',
'actual': 'connect wireless success',
'note': ''
}
cf.update_cases_result(report_file, case_name, step_2_report)
password = subprocess.getoutput(
"cat /etc/wpasupplicant.wireless.wlan0.conf") # step 3 -------------
if "neoware1234".lower() in password.lower():
log.error("wireless password not is encryption")
step_3_report = {
'step_name': 'check wireless password profile is encryption',
'result': 'Fail',
'expect': 'check wireless password profile is encryption',
'actual': 'check wireless password profile not is encryption',
'note': ''
}
cf.update_cases_result(report_file, case_name, step_3_report)
wireless.del_wireless_profile_from_reg()
wired.set_wired_connection_priority()
if not wired.check_wired_is_connected():
wired.enable_eth0()
log.error("{:+^80}".format("test case fail"))
return False
log.info("wireless password is encryption")
step_3_report = {
'step_name': 'check wireless password profile is encryption',
'result': 'Pass',
'expect': 'check wireless password profile is encryption',
'actual': 'check wireless password profile is encryption',
'note': ''
}
cf.update_cases_result(report_file, case_name, step_3_report)
log.info("start reset test environment")
wireless.del_wireless_profile_from_reg()
wired.set_wired_connection_priority()
if not wired.check_wired_is_connected():
wired.enable_eth0()
for i in range(20):
time.sleep(3)
if wired.check_wired_is_connected():
break
after = subprocess.getoutput(
"mclient --quiet get root/Network/userLockEngaged")
log.info("after userLockEngaged value {}".format(after))
if after == before:
log.info(
"after and before value are same as,not restore userLockEngaged value"
)
else:
log.info(
"userLockEngaged Different values before and after operation")
order = ("mclient --quiet set root/Network/userLockEngaged {}".format(
before))
commit = "mclient commit"
cmd = order + '&&' + commit
subprocess.getoutput(cmd)
time.sleep(3)
log.info("edit userLockEngaged value successful")
log.info("{:+^80}".format("test case pass"))
return True
def start(case_name=case_names[0], **kwargs):
global user, rdp_server
wait_time = 30
time_path = common_function.get_current_dir("time_temp.txt")
log.info("Start Wait {}".format(wait_time))
if os.path.exists(time_path):
with open(time_path, "r") as f:
now_time = f.read()
else:
with open(time_path, "w") as f:
now_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
f.write(now_time)
current_time = time.time()
before_time = time.mktime(time.strptime(now_time, "%Y-%m-%d %H:%M:%S"))
if current_time - before_time > 3600:
os.remove(time_path)
common_function.reboot_command()
common_function.SwitchThinProMode("user")
query_list = ["xen", 'freerdp', "view", "firefox"]
shadow_dict = {}
for i in query_list:
d = vdi_connection.query_item_id(i)
shadow_dict.update(d)
vdi_connection.hide_desktop_icon(id_dict=shadow_dict)
common_function.cache_collection(3)
case_name = case_name.lower()
result_file = os.path.join(common_function.get_current_dir(),
r'Test_Report',
'{}.yaml'.format(common_function.check_ip_yaml()))
user_manager = vdi_connection.MultiUserManger()
performance = Performance.get_system_obj()
test_data = os.path.join(common_function.get_current_dir(), 'Test_Data')
# --------------- pre define --------------------------
log.info('Begin to start test {}'.format(case_name))
common_function.new_cases_result(result_file, case_name)
pic_name = generate_pic_name(case_name)
local_pic_name = generate_local_name(case_name)
parameters = display_function.analyze_name(case_name)
parameters = display_function.check_resolution_support(parameters)
log.info('analyze parameter from case name')
# display_function.LinuxTools().generate_profile(parameters['layout'], parameters['monitors'])
display_function.set_display_profile(parameters)
log.info('generate xml file')
log.info('set local resolution, Wait 20s for background refresh')
display_function.LinuxTools().set_local_resolution()
log.debug("check local resolution set success")
if not set_resolution_success() and common_function.need_reboot() != -1:
common_function.change_reboot_status(-1)
common_function.reboot_command()
common_function.change_reboot_status(0)
display_function.set_background()
log.info('set local background success')
flag, first_collect_flag = local_start(case_name, result_file, test_data, local_pic_name)
if not flag:
return False
# check fresh rate-----------------------------------------------
check_fresh_rate(case_name, result_file, parameters)
# check fresh rate end-------------------------------------------
user = user_manager.get_a_available_key()
log.info('get valid user : {}'.format(user))
remote_collect_flag = False
try:
flag, remote_collect_flag = remote_start(case_name, result_file, test_data, pic_name, user_manager, parameters, performance)
except:
debug_path = common_function.get_current_dir("Test_Report/debug.log")
with open(debug_path, "a") as f:
traceback.print_exc(file=f)
traceback.print_exc()
steps = {
'step_name': 'case exception',
'result': 'Fail',
'expect': '', # can be string or pic path
'actual': 'img/{}.jpg'.format(case_name),
'note': traceback.format_exc()}
common_function.update_cases_result(result_file, case_name, steps)
finally:
log.info('try to reset user')
if user:
user_manager.reset_key(user)
if parameters['vdi'].upper() == 'RDP' and rdp_server:
user_manager.reset_key(rdp_server, key=session.lower())
if first_collect_flag or remote_collect_flag:
steps = {
'step_name': "Cannot find template PIC",
'result': 'Fail',
'expect': '', # can be string or pic path
'actual': '',
'note': 'This case has no pic in library'}
common_function.update_cases_result(result_file, case_name, steps)
log.debug(gc.garbage)
gc.collect()
def start(case_name, **kwargs):
log.info("{:-^80}".format("start a case test"))
log.info("case name:" + case_name)
report_file = os.path.join(cf.get_current_dir(), "Test_Report",
"{}.yaml".format(cf.check_ip_yaml()))
cf.new_cases_result(report_file, case_name)
cf.SwitchThinProMode("admin")
default_profile = cf.get_current_dir("Test_Data/profile.xml")
if not os.path.exists(default_profile):
log.error("not found the default profile")
check_profie_report = {
'step_name': 'check default profile file',
'result': 'Fail',
'expect': "found default profile file",
'actual': "not found default profile file",
'note': ''
}
cf.update_cases_result(report_file, case_name, check_profie_report)
log.error("{:+^80}".format("test case fail"))
return False
log.info("found the default profile")
log.info("start import the default profile")
cf.import_profile()
log.info(
"start check the value of userLockEngaged") # step 1 -------------
if userlockengaged_value() is not "0":
log.error("the default value of userLockEngaged not is '0'")
check_userLockEngaged_report = {
'step_name': 'check default profile file',
'result': 'Fail',
'expect': "userLockEngaged is '0'",
'actual': "userLockEngaged not is '0'",
'note': ''
}
cf.update_cases_result(report_file, case_name,
check_userLockEngaged_report)
log.error("{:+^80}".format("test case fail"))
return False
log.info("the default value of userLockEngaged is '0'")
check_userLockEngaged_report = {
'step_name': 'check default profile file',
'result': 'Pass',
'expect': "userLockEngaged is '0'",
'actual': "userLockEngaged is '0'",
'note': ''
}
cf.update_cases_result(report_file, case_name,
check_userLockEngaged_report)
log.info("start modify the hostname") # step 2 ---------------
dns = network_setting.DNS()
dns.open_dns()
dns.dns_set_hostname("123456")
dns.apply()
dns.close_control_panel()
log.info("check the value of userLockEngaged again"
) # step 3 -------------------
if userlockengaged_value() is not "1":
log.error("the value of userLockEngaged not is '1'")
check_userLockEngaged_report = {
'step_name': 'check default profile file',
'result': 'Fail',
'expect': "userLockEngaged auto changed to '1'",
'actual': "userLockEngaged not auto changed to '1'",
'note': ''
}
cf.update_cases_result(report_file, case_name,
check_userLockEngaged_report)
cf.import_profile()
log.error("{:+^80}".format("test case fail"))
return False
log.info("the value of userLockEngaged is '1'")
check_userLockEngaged_report = {
'step_name': 'check default profile file',
'result': 'Pass',
'expect': "userLockEngaged auto changed to '1'",
'actual': "userLockEngaged auto changed to '1'",
'note': ''
}
cf.update_cases_result(report_file, case_name,
check_userLockEngaged_report)
cf.import_profile()
wired = network_setting.Wired()
for i in range(20):
if wired.check_wired_is_connected():
break
time.sleep(2)
log.info("set 'root/Network/userLockEngaged' is 0")
os.system("mclient --quiet set root/Network/userLockEngaged 0")
os.system("mclient commit")
time.sleep(1)
log.info("{:+^80}".format("test case pass"))
return True