def start(case_name, **kwargs):
try:
log.info('Begin to start test {}'.format(case_name))
user_manager = vdi_connection.MultiUserManger()
user = user_manager.get_a_available_key()
rdp_server = user_manager.get_a_available_key('rdp win10')
conn = vdi_connection.RDPLinux(user=user, rdp_server=rdp_server)
log.info('user: {}, rdp_server: {}'.format(user, rdp_server))
report_file = os.path.join(
common_function.get_current_dir(), r'Test_Report',
'{}.yaml'.format(common_function.check_ip_yaml()))
common_function.new_cases_result(report_file, case_name)
common_function.case_steps_run_control(steps_list,
__name__,
case_name=case_name,
log=log,
report_file=report_file,
user=user,
rdp_server=rdp_server,
conn=conn,
user_manager=user_manager)
except:
log.error(traceback.format_exc())
error_pic = os.path.join(common_function.get_current_dir(),
r'Test_Report', 'img',
'{}.png'.format(case_name))
picture_operator.capture_screen(error_pic)
reset_all_settings(num=0)
return False
def start(case_name, **kwargs):
try:
log.info('Begin to start case {}'.format(case_name))
result_file = os.path.join(get_current_dir(), r'Test_Report',
'{}.yaml'.format(check_ip_yaml()))
new_cases_result(result_file, case_name)
SwitchThinProMode(switch_to='admin')
default_method = get_connection_method()
wired = Wired()
if dynamic_ip_check(case_name, result_file, wired) is False:
reset_connection_method(default_method)
return
if dynamic_ip_ping(case_name, result_file) is False:
reset_connection_method(default_method)
return
ip = get_ip()
mask = wired.get_mask('eth0')
gateway = wired.gateway()
if static_ip_check(case_name, result_file, wired, ip, mask,
gateway) is False:
reset_connection_method(default_method)
return
if static_ip_ping(case_name, result_file) is False:
reset_connection_method(default_method)
return
except:
log.error(traceback.format_exc())
error_pic = os.path.join(get_current_dir(), r'Test_Report', 'img',
'{}.png'.format(case_name))
capture_screen(error_pic)
os.system("wmctrl -c 'Control Panel'")
def start(case_name, **kwargs):
ip = check_ip_yaml()
yml_path = get_current_dir("Test_Report/{}.yaml").format(ip)
params = {"case_name": case_name,
"yml_path": yml_path}
step_list = ['step1', 'reboot', 'step3', 'resume']
case_steps_run_control(step_list, __name__, **params)
resume()
return
def start(case_name, **kwargs):
report_file = cf.get_current_dir("Test_Report",
"{}.yaml".format(cf.check_ip_yaml()))
cf.new_cases_result(report_file, case_name)
cf.case_steps_run_control(steps_list,
__name__,
case_name=case_name,
report_file=report_file)
def start(case_name, **kwargs):
ip = check_ip_yaml()
yml_path = get_current_dir("Test_Report/{}.yaml").format(ip)
screensavertool = screensaver.ScreenSaver()
params = {
"case_name": case_name,
"yml_path": yml_path,
"screensavertool": screensavertool
}
step1(**params)
SwitchThinProMode("user")
def start(case_name, **kwargs):
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)
steps_list = ("userlock_is_1", "userlock_is_0",
"userlock_is_0_after_reboot")
cf.case_steps_run_control(steps_list,
__name__,
case_name=case_name,
report_file=report_file)
def start(case_name, **kwargs):
ssid = kwargs.get("ssid", "R1-TC_5G_n")
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)
steps_list = ("step_1_2", "step_3_4")
cf.case_steps_run_control(steps_list,
__name__,
case_name=case_name,
report_file=report_file,
ssid=ssid)
def start(case_name, kwargs):
steps_list = (
"clear_proxy",
"access_website_before",
"set_proxy1",
"access_website_after",
"finish"
)
https_test = ProxyTest('https')
result_file = common_function.get_current_dir(r'Test_Report', '{}.yaml'.format(common_function.check_ip_yaml()))
common_function.new_cases_result(result_file, case_name)
common_function.case_steps_run_control(steps_list, __name__, case_name=case_name,
report_file=result_file, obj=https_test)
def start(case_name, **kwargs):
ip = check_ip_yaml()
yml_path = get_current_dir("Test_Report/{}.yaml").format(ip)
screensavertool = screensaver.ScreenSaver()
params = {"case_name": case_name,
"yml_path": yml_path,
"screensavertool": screensavertool}
flag = step1(**params)
flag = step2(**params) if flag else False
flag = step3(**params)
if not flag:
os.popen("reboot")
time.sleep(15)
return flag
def start(case_name, **kwargs):
report_file = os.path.join(common_function.get_current_dir(), "Test_Report",
"{}.yaml".format(common_function.check_ip_yaml()))
common_function.new_cases_result(report_file, case_name) # new report
steps_list = ("preparation",
"configure_pptp_vpn",
"check_configure_pptp_vpn_result",
"reboot",
"check_pptp_vpn_result_reboot",
"restore_environment"
)
common_function.case_steps_run_control(steps_list, __name__, case_name=case_name, log=pptp_vpn.log,
report_file=report_file)
def start(case_name, kwargs):
steps_list = ("set_bypass_baidu", "test_bypass_baidu",
"set_bypass_baidu_google", "test_bypass_baidu_google",
"set_bypass_contain_baidu", "test_bypass_contain_baidu",
"finish")
no_proxy_test = NoProxyTest()
result_file = common_function.get_current_dir(
r'Test_Report', '{}.yaml'.format(common_function.check_ip_yaml()))
common_function.new_cases_result(result_file, case_name)
# no_proxy_test.tp.switch_mode()
common_function.case_steps_run_control(steps_list,
__name__,
case_name=case_name,
log=log,
report_file=result_file,
obj=no_proxy_test)
def start(case_name, **kwargs):
report_file = os.path.join(common_function.get_current_dir(), "Test_Report",
"{}.yaml".format(common_function.check_ip_yaml()))
common_function.new_cases_result(report_file, case_name) # new report
steps_list = ("preparation",
"set_wireless",
"check_connected_wireless",
"move_up_ssid",
"reboot",
"check_connected_wireless_reboot",
"restore_environment"
)
common_function.case_steps_run_control(steps_list, __name__, case_name=case_name, log=wireless_pro.log,
report_file=report_file)
def __init__(self, start, end):
self.__test_report_root = get_current_dir('Test_Report')
self.__template_folder = get_current_dir('Test_Data', 'td_common',
'report')
self.__static_src = get_current_dir('Test_Data', 'td_common', 'report',
'static')
self.__name = 'report'
self.ip = check_ip_yaml()
self.__start_time = start
self.__end_time = end
self.__load_uut_result()
self.__data_by_case = self.__generate_table()
self.total = {
'Passing rate':
'%.2f' % (100 * self.__data_by_case['passCount'] /
self.__data_by_case['count']),
'Pass':
self.__data_by_case['passCount'],
'Fail':
self.__data_by_case['failCount'],
'NoRun':
self.__data_by_case['norunCount'],
'Count':
self.__data_by_case['count']
}
self.pie_chart_data = [
{
'value': self.total['Pass'],
'name': 'Pass',
'itemStyle': {
'color': '#5cb85c'
}
},
{
'value': self.total['Fail'],
'name': 'Fail',
'itemStyle': {
'color': '#d9534f'
}
},
]
self.framework_version = '1.0'
self.script_version = '1.0'
pass
def start(case_name, **kwargs):
try:
log.info('Begin to start case {}'.format(case_name))
result_file = os.path.join(get_current_dir(), r'Test_Report',
'{}.yaml'.format(check_ip_yaml()))
new_cases_result(result_file, case_name)
SwitchThinProMode(switch_to='admin')
if not check_fiber_exist():
log.error("not found fiber card on thin client")
pre_check_report = {
'step_name': 'check_fiber_exist',
'result': 'Fail',
'expect': 'has fiber card on thin client',
'actual': 'not found fiber card on thin client',
'note': ''
}
cf.update_cases_result(result_file, case_name, pre_check_report)
log.error("test case {} fail".format(case_name))
return False
default_method = get_connection_method()
wired = Wired()
if dynamic_ip_check(case_name, result_file, wired) is False:
reset_connection_method(default_method)
return
if dynamic_ip_ping(case_name, result_file) is False:
reset_connection_method(default_method)
return
mask = wired.get_mask('eth1')
gateway = wired.gateway()
ip = modify_ip(gateway)
if static_ip_check(case_name, result_file, wired, ip, mask,
gateway) is False:
reset_connection_method(default_method)
return
if static_ip_ping(case_name, result_file) is False:
reset_connection_method(default_method)
return
except:
log.debug(
traceback.format_exc(),
get_current_dir('Test_Report', 'img', '{}.png'.format(case_name)))
os.system("wmctrl -c 'Control Panel'")
def start(case_name, **kwargs):
ip = check_ip_yaml()
yml_path = get_current_dir("Test_Report/{}.yaml").format(ip)
power_manager = PowerManagerFactory("AC", "ScreenSaver")
screensavertool = screensaver.ScreenSaver()
params = {
"case_name": case_name,
"yml_path": yml_path,
"screensavertool": screensavertool,
"power_manager": power_manager
}
flag = step1(**params)
flag = step2(**params) if flag else False
flag = step3(**params) if flag else False
flag = step4(**params) if flag else False
flag = step5(**params) if flag else False
flag = step6(**params) if flag else False
power_manager.close_all_power_manager()
resume_all_settings(**params)
return flag
def start(case_name, **kwargs):
report_file = os.path.join(
common_function.get_current_dir(), "Test_Report",
"{}.yaml".format(common_function.check_ip_yaml()))
common_function.new_cases_result(report_file, case_name) # new report
cisco_vpn = EditCiscoVPN()
switch_result = cisco_vpn.switch_user('admin')
cisco_vpn.update_case_result(switch_result, 'switch_user', report_file,
case_name)
if not switch_result:
cisco_vpn.deal_with_unexpected('fail_switch_admin.png')
return False
configure_result = cisco_vpn.cisco_vpn_connection('profile_1')
cisco_vpn.update_case_result(configure_result,
'cisco_vpn_connection_create', report_file,
case_name)
if not configure_result:
cisco_vpn.deal_with_unexpected('fail_cisco_vpn_connection_create.png')
return False
cisco_vpn.check_vpn_result()
edit_result = cisco_vpn.cisco_vpn_connection('profile_edit')
cisco_vpn.update_case_result(edit_result, 'cisco_vpn_connection_edit',
report_file, case_name)
if not edit_result:
cisco_vpn.deal_with_unexpected('fail_cisco_vpn_connection_edit.png')
return False
if not cisco_vpn.open_network_vpn_dialog():
cisco_vpn.log.info('Failt to open_network_vpn_dialog after edit')
cisco_vpn.deal_with_unexpected(
'fail_open_network_vpn_dialog_after_edit.png')
return False
grp_passwd = cisco_vpn.wait_pictures('group_password_empty_cisco')
user_name = cisco_vpn.wait_pictures('user_name_empty_cisco')
if grp_passwd and user_name:
cisco_vpn.update_case_result(True, 'check_cisco_vpn_connection_edit',
report_file, case_name)
else:
cisco_vpn.update_case_result(False, 'check_cisco_vpn_connection_edit',
report_file, case_name)
cisco_vpn.close_control_panel()
cisco_vpn.restore_default_settings()
def start(case_name, *args, **kwargs):
try:
log.info('Begin to start test {}'.format(case_name))
result_file = os.path.join(
common_function.get_current_dir(), r'Test_Report',
'{}.yaml'.format(common_function.check_ip_yaml()))
common_function.new_cases_result(result_file, case_name)
common_function.case_steps_run_control(steps_list,
__name__,
case_name=case_name,
log=log,
report_file=result_file)
reset_settings()
log.info('test case {} is end'.format(case_name))
except:
log.error(traceback.format_exc())
error_pic = os.path.join(common_function.get_current_dir(),
r'Test_Report', 'img',
'{}.png'.format(case_name.replace(' ', '_')))
capture_screen(error_pic)
pass
def start(case_name, **kwargs):
report_file = os.path.join(common_function.get_current_dir(), "Test_Report",
"{}.yaml".format(common_function.check_ip_yaml()))
common_function.new_cases_result(report_file, case_name) # new report
steps_list = ("switch_to_admin",
"enable_timed_system_lock",
"set_lockinfo",
"check_lockinfo_in_dialog",
"set_locktime",
"check_locktime_in_dialog",
"reboot",
"check_lockinfo_in_dialog_reboot",
"check_locktime_in_dialog_reboot"
)
pyautogui.moveTo(1, 1) # Move cursor in case it's at the corner of screen and PyAutuGui fail-safe is triggered
time.sleep(1)
common_function.case_steps_run_control(steps_list, __name__, case_name=case_name, log=screen_lock.log,
report_file=report_file)
def start(case_name, **kwargs):
try:
result_file = os.path.join(get_current_dir(), r'Test_Report',
'{}.yaml'.format(check_ip_yaml()))
log.info('Begin to start test {}'.format(case_name))
new_cases_result(result_file, case_name)
SwitchThinProMode(switch_to='admin')
wireless = Wireless()
wireless.wired_wireless_switch('off')
time.sleep(5)
wireless.open_network()
wireless.switch_to_wireless_tab()
if add_wl(wireless, "R1-TC_5G_n", case_name, result_file) is False:
wireless.close_control_panel()
return
edit_value_dict = {
"ssid": "R1-TC_2.4G_n_WPA2P",
"authentication": "WPA/WPA2-PSK",
"password": "******"
}
if edit_wl(wireless, "R1-TC_5G_n", edit_value_dict, case_name,
result_file) is False:
wireless.close_control_panel()
return
if delete_wl(wireless, "R1-TC_2.4G_n_WPA2P", case_name, result_file):
wireless.close_control_panel()
return
reset_setting(wireless, 'R1-TC_5G_n')
reset_setting(wireless, 'R1-TC_2.4G_n_WPA2P')
wireless.close_control_panel()
except:
log.error(traceback.format_exc())
error_pic = os.path.join(get_current_dir(), r'Test_Report', 'img',
'{}.png'.format(case_name))
capture_screen(error_pic)
os.system("wmctrl -c 'Control Panel'")
def start(case_name, **kwargs):
report_file = os.path.join(
common_function.get_current_dir(), "Test_Report",
"{}.yaml".format(common_function.check_ip_yaml()))
common_function.new_cases_result(report_file, case_name) # new report
scr_lock_passw = ScreenLockPassword()
log = scr_lock_passw.log
log.info('-------------Start step 1 & 2-------------------')
scr_lock_passw.set_screen_saver()
if not scr_lock_passw.switch_user('user'):
log.error('switch to user fail')
return False
scr_lock_passw.create_vdi_rdp('step1&2')
for _ in range(2):
if scr_lock_passw.connect_vdi_rdp() is True:
break
log.debug(
'connect vdi rdp for step 1&2 fail,try again',
common_function.get_current_dir(
"Test_Report", "img",
"{}.png".format(case_name.replace(' ', '_'))))
else:
step = {
'step_name': 'Connect vdi rdp for step 1&2',
'result': 'Fail',
'expect': 'Vdi rdp should be connected.',
'actual': 'Fail to connect vdi rdp.',
'note': 'none'
}
common_function.update_cases_result(report_file, case_name, step)
scr_lock_passw.restore_default_settings()
return False
if not scr_lock_passw.lock_screen(passw=False):
step = {
'step_name': 'Lock screen for step 1&2',
'result': 'Fail',
'expect': 'Screen should be locked.',
'actual': 'Fail to lock screen.',
'note': 'none'
}
common_function.update_cases_result(report_file, case_name, step)
scr_lock_passw.logoff_vdi_rdp()
return False
pyautogui.click()
time.sleep(2)
if not scr_lock_passw.step_unlock_result(report_file, case_name):
log.debug(
"try to unlock vdi screen",
common_function.get_current_dir(
"Test_Report", "img",
"{}.png".format(case_name.replace(' ', '_'))))
pyautogui.click()
screen = scr_lock_passw.wait_pictures('_lock_screen')
if screen:
passw = scr_lock_passw.vdi_user_info["password"]
pyautogui.typewrite(passw, interval=0.1)
pyautogui.press("enter")
time.sleep(2)
if screen:
pyautogui.press("enter")
time.sleep(1)
pyautogui.click()
time.sleep(1)
pyautogui.press("esc")
time.sleep(2)
pyautogui.click()
time.sleep(2)
pyautogui.typewrite('1')
pyautogui.press("enter")
time.sleep(2)
scr_lock_passw.logoff_vdi_rdp()
else:
scr_lock_passw.logoff_vdi_rdp()
time.sleep(20)
pyautogui.click()
return False
if not scr_lock_passw.step_logoff(report_file, case_name):
return False
step_1_2 = {
'step_name': 'Step 1&2: Unlock with general user without password',
'result': 'Pass',
'expect': 'Pass.',
'actual': 'Pass.',
'note': 'none'
}
common_function.update_cases_result(report_file, case_name, step_1_2)
log.info('-------------Finish step 1 & 2-------------------')
time.sleep(2)
log.info('-------------Start step 3 & 4-------------------')
scr_lock_passw.create_vdi_rdp('step3&4')
for _ in range(2):
if scr_lock_passw.connect_vdi_rdp() is True:
break
log.debug(
'connect vdi rdp for step 3&4 fail,try again',
common_function.get_current_dir(
"Test_Report", "img",
"{}.png".format(case_name.replace(' ', '_'))))
else:
step = {
'step_name': 'Connect vdi rdp for step 3&4',
'result': 'Fail',
'expect': 'Vdi rdp should be connected.',
'actual': 'Fail to connect vdi rdp.',
'note': 'none'
}
common_function.update_cases_result(report_file, case_name, step)
scr_lock_passw.restore_default_settings()
return False
if not scr_lock_passw.lock_screen():
step = {
'step_name': 'Lock screen for step 3&4',
'result': 'Fail',
'expect': 'Screen should be locked.',
'actual': 'Fail to lock screen.',
'note': 'none'
}
common_function.update_cases_result(report_file, case_name, step)
scr_lock_passw.logoff_vdi_rdp()
return False
passw = scr_lock_passw.vdi_user_info["password"]
pyautogui.typewrite(passw, interval=0.1)
pyautogui.press("enter")
time.sleep(2)
if not scr_lock_passw.step_unlock_result(report_file, case_name):
scr_lock_passw.logoff_vdi_rdp()
return False
if not scr_lock_passw.step_logoff(report_file, case_name):
scr_lock_passw.logoff_vdi_rdp()
return False
step_3_4 = {
'step_name': 'Step 3&4: Unlock with connection credentials',
'result': 'Pass',
'expect': 'Pass.',
'actual': 'Pass.',
'note': 'none'
}
common_function.update_cases_result(report_file, case_name, step_3_4)
log.info('-------------Finish step 3 & 4-------------------')
time.sleep(2)
log.info('-------------Start step 5 & 6-------------------')
rdp, user, rdp_server = scr_lock_passw.create_vdi_rdp('step5&6')
rdp.delete_vdi('freerdp')
rdp.create_vdi('freerdp')
time.sleep(1)
rdp_id = rdp.vdi_connection_id('freerdp')[0]
dic = {
'credentialsType': 'password',
'domain': 'sh',
'securityLevel': '0',
'windowType': 'full',
'address': rdp_server,
'SingleSignOn': '1'
}
rdp.set_vdi(rdp_id, dic)
# rdp.connect_vdi(rdp_id)
for _ in range(2):
rdp.connect_vdi_by_pic()
log.info("Launch RDP Login dialog.")
time.sleep(5)
pyautogui.typewrite(user)
time.sleep(1)
pyautogui.hotkey('tab')
time.sleep(1)
pyautogui.typewrite(passw)
time.sleep(1)
pyautogui.hotkey('enter')
time.sleep(10)
screen = scr_lock_passw.wait_pictures('_win10_start_icon')
if screen:
break
log.debug(
'connect vdi rdp for step 5&6 fail,try again',
common_function.get_current_dir(
"Test_Report", "img",
"{}.png".format(case_name.replace(' ', '_'))))
else:
step = {
'step_name': 'Connect vdi rdp for step 5&6',
'result': 'Fail',
'expect': 'Vdi rdp should be connected.',
'actual': 'Fail to connect vdi rdp.',
'note': 'none'
}
common_function.update_cases_result(report_file, case_name, step)
scr_lock_passw.restore_default_settings()
return False
if not scr_lock_passw.lock_screen():
step = {
'step_name': 'Lock screen for step 5&6',
'result': 'Fail',
'expect': 'Screen should be locked.',
'actual': 'Fail to lock screen.',
'note': 'none'
}
common_function.update_cases_result(report_file, case_name, step)
scr_lock_passw.logoff_vdi_rdp()
return False
# pyautogui.hotkey('enter')
# time.sleep(2)
# user should not in the list of new credentials
if not scr_lock_passw.step_check_user_in_credential_list(
False, report_file, case_name):
scr_lock_passw.logoff_vdi_rdp()
return False
log.info("Use 'root' to unlock.")
scr_lock_passw.unlock_with_specified_account('root', '1')
if not scr_lock_passw.wait_pictures(
"_invalid_credentials"): # check invalid credentials dialog
scr_lock_passw.log.info("Not found invalid credentials dialog")
scr_lock_passw.logoff_vdi_rdp()
return False
pyautogui.press("enter")
cancel = scr_lock_passw.wait_pictures("_cancel")
pyautogui.click(cancel)
time.sleep(1)
pyautogui.press("enter")
time.sleep(1)
pyautogui.typewrite(passw, interval=0.1)
pyautogui.press("enter")
time.sleep(2)
if not scr_lock_passw.step_unlock_result(report_file, case_name):
scr_lock_passw.logoff_vdi_rdp()
return False
if not scr_lock_passw.step_logoff(report_file, case_name):
return False
step_5_6 = {
'step_name':
'Step 5&6: Check user in locked account list and unlock with root, connection credentials',
'result': 'Pass',
'expect': 'Pass.',
'actual': 'Pass.',
'note': 'none'
}
common_function.update_cases_result(report_file, case_name, step_5_6)
log.info('-------------Finish step 5 & 6-------------------')
time.sleep(2)
log.info('-------------Start step 7 & 8-------------------')
scr_lock_passw.set_user_password(password='******')
scr_lock_passw.set_screen_saver(True)
if not scr_lock_passw.switch_user('user'):
return False
if not scr_lock_passw.lock_screen(locked_by='user'):
step = {
'step_name': 'Lock screen by user for step 7&8',
'result': 'Fail',
'expect': 'Screen should be locked by user.',
'actual': 'Fail to lock screen by user.',
'note': 'none'
}
common_function.update_cases_result(report_file, case_name, step)
# restore settings to default
scr_lock_passw.restore_default_settings()
return False
pyautogui.typewrite('1')
time.sleep(1)
pyautogui.press("enter")
time.sleep(2)
# if not scr_lock_passw.step_unlock_result(report_file, case_name, unlock_result='linux'):
# # restore settings to default
# scr_lock_passw.restore_default_settings()
# return False
if scr_lock_passw.wait_pictures('_lock_screen'):
step = {
'step_name': 'Unlock screen by user for step 7&8',
'result': 'Fail',
'expect': 'Screen should be unlocked by user.',
'actual': 'Fail to unlock screen by user.',
'note': 'none'
}
common_function.update_cases_result(report_file, case_name, step)
# restore settings to default
scr_lock_passw.restore_default_settings()
return False
else:
step = {
'step_name': 'Unlock screen by user for step 7&8',
'result': 'Pass',
'expect': 'Screen should be unlocked by user.',
'actual': 'Unlock screen by user successfully.',
'note': 'none'
}
common_function.update_cases_result(report_file, case_name, step)
log.info('-------------Finish step 7 & 8-------------------')
time.sleep(2)
log.info('-------------Start step 9-------------------')
scr_lock_passw.create_vdi_rdp('step3&4')
for _ in range(2):
if scr_lock_passw.connect_vdi_rdp() is True:
break
log.debug(
'connect vdi rdp for step 9 fail,try again',
common_function.get_current_dir(
"Test_Report", "img",
"{}.png".format(case_name.replace(' ', '_'))))
else:
step = {
'step_name': 'Connect vdi rdp for step 9',
'result': 'Fail',
'expect': 'Vdi rdp should be connected.',
'actual': 'Fail to connect vdi rdp.',
'note': 'none'
}
common_function.update_cases_result(report_file, case_name, step)
# restore settings to default
scr_lock_passw.restore_default_settings()
return False
# Unlock with connection credential.
if not scr_lock_passw.lock_screen():
step = {
'step_name': 'Lock screen step9_1',
'result': 'Fail',
'expect': 'Screen should be locked.',
'actual': 'Fail to lock screen.',
'note': 'none'
}
common_function.update_cases_result(report_file, case_name, step)
scr_lock_passw.logoff_vdi_rdp()
# restore settings to default
scr_lock_passw.restore_default_settings()
return False
# user should in the list of new credentials
if not scr_lock_passw.step_check_user_in_credential_list(
True, report_file, case_name):
scr_lock_passw.logoff_vdi_rdp()
# restore settings to default
scr_lock_passw.restore_default_settings()
return False
pyautogui.typewrite(passw, interval=0.1)
pyautogui.press("enter")
time.sleep(2)
if not scr_lock_passw.step_unlock_result(report_file, case_name):
scr_lock_passw.logoff_vdi_rdp()
# restore settings to default
scr_lock_passw.restore_default_settings()
return False
# Unlock with User.
if not scr_lock_passw.lock_screen():
step = {
'step_name': 'Lock screen step9_2',
'result': 'Fail',
'expect': 'Screen should be locked.',
'actual': 'Fail to lock screen.',
'note': 'none'
}
common_function.update_cases_result(report_file, case_name, step)
scr_lock_passw.logoff_vdi_rdp()
# restore settings to default
scr_lock_passw.restore_default_settings()
return False
log.info("Use 'user' to unlock.")
scr_lock_passw.unlock_with_specified_account('user', '1')
if not scr_lock_passw.step_unlock_result(report_file, case_name):
scr_lock_passw.logoff_vdi_rdp()
# restore settings to default
scr_lock_passw.restore_default_settings()
return False
if not scr_lock_passw.step_logoff(report_file, case_name):
scr_lock_passw.logoff_vdi_rdp()
# restore settings to default
scr_lock_passw.restore_default_settings()
return False
step_9 = {
'step_name': 'Step 9: Unlock with connection credentials and user',
'result': 'Pass',
'expect': 'Pass.',
'actual': 'Pass.',
'note': 'none'
}
common_function.update_cases_result(report_file, case_name, step_9)
# restore settings to default
scr_lock_passw.restore_default_settings()
log.info('-------------Finish step 9-------------------')
time.sleep(2)
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):
try:
result_file = os.path.join(
common_function.get_current_dir(), r'Test_Report',
'{}.yaml'.format(common_function.check_ip_yaml()))
log.info('Begin to start test {}'.format(case_name))
new_cases_result(result_file, case_name)
SwitchThinProMode(switch_to='admin')
if check_sleep_status():
steps = {
'step_name': 'check "Minutes before system sleep"',
'result': 'Pass',
'expect': 'enable',
'actual': 'it is enable',
'note': ''
}
update_cases_result(result_file, case_name, steps)
else:
steps = {
'step_name': 'check "Minutes before system sleep"',
'result': 'Fail',
'expect': 'enable',
'actual': 'not enable',
'note': ''
}
update_cases_result(result_file, case_name, steps)
log.info('{} end'.format(case_name))
return False
last_time_gap = int(sleep_method1())
if last_time_gap > 5:
steps = {
'step_name': 'check tc go to sleep after 1 minute',
'result': 'Pass',
'expect': 'sleep',
'actual': 'TC go to sleep',
'note': ''
}
update_cases_result(result_file, case_name, steps)
else:
steps = {
'step_name': 'check tc go to sleep after 1 minute',
'result': 'Fail',
'expect': 'sleep',
'actual': 'TC not go to sleep',
'note': 'sleep time: {}'.format(last_time_gap)
}
update_cases_result(result_file, case_name, steps)
os.system("wmctrl -c 'Control Panel'")
log.info('{} end'.format(case_name))
return False
last_time_gap = int(sleep_method2(sleep_desktop))
if last_time_gap > 5:
steps = {
'step_name': 'check tc go to sleep by desktop',
'result': 'Pass',
'expect': 'sleep',
'actual': 'TC go to sleep',
'note': ''
}
update_cases_result(result_file, case_name, steps)
else:
error_pic = os.path.join(
common_function.get_current_dir(), r'Test_Report', 'img',
'{}+sleep_by_desktop.png'.format(case_name.replace(' ', '_')))
capture_screen(error_pic)
steps = {
'step_name': 'check tc go to sleep by desktop',
'result': 'Fail',
'expect': 'sleep',
'actual': 'TC not go to sleep',
'note': '{}'.format(error_pic)
}
update_cases_result(result_file, case_name, steps)
log.info('{} end'.format(case_name))
return False
last_time_gap = int(sleep_method2(sleep_start_menu))
if last_time_gap > 5:
steps = {
'step_name': 'check tc go to sleep by start menu',
'result': 'Pass',
'expect': 'sleep',
'actual': 'TC go to sleep',
'note': 'sleep time: {}'.format(last_time_gap)
}
update_cases_result(result_file, case_name, steps)
else:
error_pic = os.path.join(
common_function.get_current_dir(), r'Test_Report', 'img',
'{}+sleep_by_start_menu.png'.format(case_name.replace(
' ', '_')))
capture_screen(error_pic)
steps = {
'step_name': 'check tc go to sleep by start menu',
'result': 'Fail',
'expect': 'sleep',
'actual': 'TC not go to sleep',
'note': '{}'.format(error_pic)
}
update_cases_result(result_file, case_name, steps)
log.info('{} end'.format(case_name))
return False
log.info('{} end'.format(case_name))
except:
log.error(traceback.format_exc())
error_pic = os.path.join(common_function.get_current_dir(),
r'Test_Report', 'img',
'{}.png'.format(case_name.replace(' ', '_')))
capture_screen(error_pic)
os.system("wmctrl -c 'Control Panel'")
pass
def start(case_name, **kwargs):
try:
result_file = os.path.join(
common_function.get_current_dir(), r'Test_Report',
'{}.yaml'.format(common_function.check_ip_yaml()))
log.info('Begin to start test {}'.format(case_name))
common_function.new_cases_result(result_file, case_name)
SwitchThinProMode(switch_to='admin')
sleep_time = check_ac_default_value()
if sleep_time == '30':
steps = {
'step_name': 'check the default value on AC',
'result': 'Pass',
'expect': '30',
'actual': '30',
'note': ''
}
common_function.update_cases_result(result_file, case_name, steps)
else:
steps = {
'step_name': 'check the default value on AC',
'result': 'Fail',
'expect': '30',
'actual': 'The default value is wrong',
'note': ''
}
common_function.update_cases_result(result_file, case_name, steps)
log.info('case {} is end'.format(case_name))
return False
with PrepareWakeUp(time=1810) as w:
w.wait(1810)
to_os = ScreenSaver()
to_os.resume_lock_screen_by_mouse()
last_time_gap = int(w.get_max_time_gap())
if last_time_gap > 5:
steps = {
'step_name':
'check the os go to verify_s3_work afer 30 minutes',
'result': 'Pass',
'expect': 'sleep',
'actual': 'it is go to sleep',
'note': ''
}
common_function.update_cases_result(result_file, case_name, steps)
else:
steps = {
'step_name':
'check the os go to verify_s3_work afer 30 minutes',
'result': 'Fail',
'expect': 'sleep',
'actual': 'it is not go to sleep',
'note': 'time gap: {}, must more than 5'.format(last_time_gap)
}
common_function.update_cases_result(result_file, case_name, steps)
return False
if last_time_gap > 5:
steps = {
'step_name': 'check the os wake up',
'result': 'Pass',
'expect': 'wake up',
'actual': 'System can wake up immediately',
'note': ''
}
common_function.update_cases_result(result_file, case_name, steps)
else:
steps = {
'step_name': 'check the os wake up',
'result': 'Fail',
'expect': 'wake up',
'actual': 'System not wake up immediately',
'note': ''
}
common_function.update_cases_result(result_file, case_name, steps)
log.info('case {} is end'.format(case_name))
except:
log.error(traceback.format_exc())
error_pic = os.path.join(common_function.get_current_dir(),
r'Test_Report', 'img',
'{}.png'.format(case_name.replace(' ', '_')))
capture_screen(error_pic)
pass
def start(case_name, **kwargs):
try:
result_file = os.path.join(common_function.get_current_dir(),
r'Test_Report', '{}.yaml'.format(common_function.check_ip_yaml()))
log.info('Begin to start test {}'.format(case_name))
new_cases_result(result_file, case_name)
SwitchThinProMode(switch_to='admin')
power_manager = PowerManagerFactory("AC")
if not power_manager.AC.open_power_manager_from_control_panel():
steps = {
'step_name': 'verify the cpu run with ondemand on AC',
'result': 'Fail',
'expect': '',
'actual': '',
'note': 'power manager open fail'}
update_cases_result(result_file, case_name, steps)
return False
power_manager.AC.switch()
default_mode = get_cup_mode()
cpu_mhz_list = []
loop_result = []
for i in range(3):
cpu_mode = get_cup_mode()
value = verify_cpu_mhz(cpu_mode, case_name, power_manager)
cpu_mhz_list.append(abs(float(value[0])-float(value[1])))
loop_result.append(value)
time.sleep(2)
reset_settings(default_mode, power_manager)
power_manager.AC.close_all_power_manager()
log.info('cpu mhz list: {}'.format(cpu_mhz_list))
value = max(cpu_mhz_list)
if default_mode == 'ondemand':
steps = {
'step_name': 'verify the cpu run with ondemand on AC',
'result': 'Pass',
'expect': 'ondemand',
'actual': 'ondemand',
'note': ''}
update_cases_result(result_file, case_name, steps)
else:
steps = {
'step_name': 'verify the cpu run with ondemand on AC',
'result': 'Fail',
'expect': 'ondemand',
'actual': '{}'.format(default_mode),
'note': ''}
update_cases_result(result_file, case_name, steps)
if float(value) > 500:
steps = {
'step_name': 'check the cpu mhz',
'result': 'Pass',
'expect': '>500',
'actual': '{}'.format(value),
'note': ''}
update_cases_result(result_file, case_name, steps)
else:
steps = {
'step_name': 'check the cpu mhz',
'result': 'Fail',
'expect': '>500',
'actual': '{}'.format(value),
'note': 'loop 3 times result:{}'.format(loop_result)}
update_cases_result(result_file, case_name, steps)
log.info('{} end'.format(case_name))
except:
log.error(traceback.format_exc())
error_pic = os.path.join(common_function.get_current_dir(),
r'Test_Report', 'img', '{}.png'.format(case_name))
capture_screen(error_pic)
power_manager = PowerManagerFactory("AC")
power_manager.AC.close_all_power_manager()
pass
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):
ethernet_speed = kwargs.get("ethernet_speed", "Automatic")
speed = kwargs.get("speed", "1000Mb/s")
duplex = kwargs.get("duplex", "Full")
auto_negotiation = kwargs.get("auto_negotiation", "on")
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))
if not pre_check():
pre_check_report = {
'step_name': 'pre_check',
'result': 'Fail',
'expect': 'ThinPro connected wired',
'actual': 'ThinPro not connected wired',
'note': ''
}
cf.update_cases_result(report_file, case_name, pre_check_report)
log.error("{:+^80}".format("test case fail"))
return False
wired = network_setting.Wired()
if not set_eth0_speed(ethernet_speed=ethernet_speed): # set Ethernet Speed
set_speed_report = {
'step_name': 'set eth0 speed',
'result': 'Fail',
'expect': "set 'Ethernet Speed' success",
'actual': "set 'Ethernet Speed' fail",
'note': ''
}
cf.update_cases_result(report_file, case_name, set_speed_report)
wired.close_control_panel()
reset_test_environment()
log.error("{:+^80}".format("test case fail"))
return False
for i in range(24):
log.info("wait wired reconnect...")
time.sleep(5)
if wired.check_wired_is_connected():
log.info("wired is connected")
break
else:
log.error("reconnect wired time out 2 minutes")
reconnect_wired_report = {
'step_name': 'reconnect wired',
'result': 'Fail',
'expect': "reconnect wired success",
'actual': "reconnect wired time out 2 minutes",
'note': ''
}
cf.update_cases_result(report_file, case_name, reconnect_wired_report)
reset_test_environment()
log.error("{:+^80}".format("test case fail"))
return False
eth0_speed = get_eth0_speed()
if eth0_speed["speed"] == speed and eth0_speed["duplex"] == duplex and \
eth0_speed["auto-negotiation"] == auto_negotiation:
log.info("eth0 speed is '{}'".format(eth0_speed["speed"]))
log.info("eth0 duplex is '{}'".format(eth0_speed["duplex"]))
log.info("eth0 auto-negotiation is '{}'".format(
eth0_speed["auto-negotiation"]))
else:
log.error("eth0 speed is '{}'".format(eth0_speed["speed"]))
log.error("eth0 duplex is '{}'".format(eth0_speed["duplex"]))
log.error("eth0 auto-negotiation is '{}'".format(
eth0_speed["auto-negotiation"]))
check_speed_report = {
'step_name':
'check eth0 speed',
'result':
'Fail',
'expect':
"eth0 speed is '{}', '{}', '{}'".format(speed, duplex,
auto_negotiation),
'actual':
"eth0 speed is '{speed}', '{duplex}', '{auto-negotiation}'".
format_map(eth0_speed),
'note':
''
}
cf.update_cases_result(report_file, case_name, check_speed_report)
reset_test_environment()
log.error("{:+^80}".format("test case fail"))
return False
reset_test_environment()
check_speed_report = {
'step_name':
'check eth0 speed',
'result':
'Pass',
'expect':
"eth0 speed is '{}', '{}', '{}'".format(speed, duplex,
auto_negotiation),
'actual':
"eth0 speed is '{speed}', '{duplex}', '{auto-negotiation}'".format_map(
eth0_speed),
'note':
''
}
cf.update_cases_result(report_file, case_name, check_speed_report)
del wired
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, **kwargs):
resolution = pyautogui.size()
common_function.log.info(resolution)
report_file = os.path.join(
common_function.get_current_dir(), "Test_Report",
"{}.yaml".format(common_function.check_ip_yaml()))
common_function.new_cases_result(report_file, case_name) # new report
power_menu = PowerMenuChange()
log = power_menu.log
img_path = power_menu.img_path
pyautogui.moveTo(
1, 1
) # Move cursor in case it's at the corner of screen and PyAutuGui fail-safe is triggered
time.sleep(1)
power_menu.switch_user('admin')
power_menu.open_power_menu()
default = power_menu.check_power_menu_default()
if default:
step1 = {
'step_name': 'Check power menu default values',
'result': 'Pass',
'expect':
'Power menu is set by default. All checkboxes are checked.',
'actual':
'Power menu is set by default. All checkboxes are checked.',
'note': 'none'
}
common_function.update_cases_result(report_file, case_name, step1)
else:
pyautogui.screenshot(img_path + 'power_menu_default.png')
time.sleep(1)
step1 = {
'step_name': 'Check power menu default values',
'result': 'Fail',
'expect':
'Power menu is set by default. All checkboxes are checked.',
'actual': 'Power menu is not set by default.',
'note': 'power_menu_default.png'
}
common_function.update_cases_result(report_file, case_name, step1)
power_menu.close_window()
return False
power_menu.close_window()
log.info('finish step1')
step2 = power_menu.check_result('admin', 'power_option_desktop',
'power_option_start', 'step2')
common_function.update_cases_result(report_file, case_name, step2)
# if not step2['result']:
# return False
# if step2['result'].upper() == 'FAIL':
# return False
log.info('finish step2')
# Disable power menu show for regular user
power_menu.click_power_menu_show_checkbox()
step3 = power_menu.check_result('user', 'no_power_option_desktop',
'no_power_option_start', 'step3')
common_function.update_cases_result(report_file, case_name, step3)
# if not step3['result']:
# return False
# if step3['result'].upper() == 'FAIL':
# return False
log.info('finish step3')
step4 = power_menu.check_result('admin', 'power_option_desktop',
'power_option_start', 'step4')
common_function.update_cases_result(report_file, case_name, step4)
# if not step4['result']:
# return False
# if step4['result'].upper() == 'FAIL':
# return False
log.info('finish step4')
# Enable power menu show but disable sub menus
power_menu.click_power_menu_show_checkbox()
power_menu.click_power_sub_menu_checkbox()
step5 = power_menu.check_result('user', 'no_power_option_desktop',
'no_power_option_start', 'step5')
common_function.update_cases_result(report_file, case_name, step5)
# if not step5['result']:
# return False
# if step5['result'].upper() == 'FAIL':
# return False
step6 = power_menu.check_result('admin', 'power_option_desktop',
'power_option_start', 'step6')
common_function.update_cases_result(report_file, case_name, step6)
# if not step6['result']:
# return False
# if step6['result'].upper() == 'FAIL':
# return False
log.info('finish step5, step6')
# Enable sub menus
power_menu.click_power_sub_menu_checkbox()
step7 = power_menu.check_result('user', 'power_option_desktop',
'power_option_start', 'step7')
common_function.update_cases_result(report_file, case_name, step7)
# if not step7['result']:
# return False
# if step7['result'].upper() == 'FAIL':
# return False
log.info('finish step 7')
# Check power option sub menus
power_m_desktop, power_m_start = power_menu.check_power_menu_in_desktop_and_start_menu(
'user', 'step8')
if power_m_desktop and power_m_start:
step8 = {
'step_name': 'Check power menu in desktop and Start menu for user',
'result': 'Pass',
'expect': 'Power menu should exist in desktop and Start menu.',
'actual': 'Power menu should exist in desktop and Start menu.',
'note': 'none'
}
else:
step8 = {
'step_name':
'Check power menu in desktop and Start menu for user',
'result':
'Fail',
'expect':
'Power menu should exist in desktop and Start menu.',
'actual':
'No power menu exists in desktop or Start menu. Desktop result: {0}, Start menu result: '
'{1}'.format(power_m_desktop, power_m_start),
'note':
'power_menu_desktop_step8.png, power_menu_start_step8.png'
}
common_function.update_cases_result(report_file, case_name, step8)
log.info('finish step 8')
def start(case_name, **kwargs):
try:
result_file = os.path.join(
common_function.get_current_dir(), r'Test_Report',
'{}.yaml'.format(common_function.check_ip_yaml()))
log.info('Begin to start test {}'.format(case_name))
new_cases_result(result_file, case_name)
SwitchThinProMode(switch_to='admin')
if 'mt' not in get_platform().lower():
log.warning('There is no need to run this case on DTC')
step1 = {
'step_name': 'check current platform',
'result': 'Fail',
'expect': '',
'actual': '',
'note': 'current platform is not mtc, skip the case'
}
common_function.update_cases_result(result_file, case_name, step1)
return
power_manager = PowerManagerFactory("Battery")
power_manager.Battery.open_power_manager_from_control_panel()
power_manager.Battery.switch()
default_mode = get_cup_mode()
cpu_mhz_list = []
loop_result = []
for i in range(3):
cpu_mode = get_cup_mode()
value = verify_cpu_mhz(cpu_mode, case_name, power_manager)
cpu_mhz_list.append(abs(float(value[0]) - float(value[1])))
loop_result.append(value)
time.sleep(2)
reset_settings(default_mode, power_manager)
power_manager.Battery.close_all_power_manager()
log.info('cpu mhz list: {}'.format(cpu_mhz_list))
value = max(cpu_mhz_list)
if default_mode == 'ondemand':
steps = {
'step_name': 'verify the cpu run with ondemand on Battery',
'result': 'Pass',
'expect': 'ondemand',
'actual': 'ondemand',
'note': ''
}
update_cases_result(result_file, case_name, steps)
else:
steps = {
'step_name': 'verify the cpu run with ondemand on Battery',
'result': 'Fail',
'expect': 'ondemand',
'actual': '{}'.format(default_mode),
'note': ''
}
update_cases_result(result_file, case_name, steps)
if float(value) > 500:
steps = {
'step_name': 'check the cpu mhz',
'result': 'Pass',
'expect': '>500',
'actual': '{}'.format(value),
'note': ''
}
update_cases_result(result_file, case_name, steps)
else:
steps = {
'step_name': 'check the cpu mhz',
'result': 'Fail',
'expect': '>500',
'actual': '{}'.format(value),
'note': 'loop 3 times result:{}'.format(loop_result)
}
update_cases_result(result_file, case_name, steps)
log.info('{} end'.format(case_name))
except:
log.error(traceback.format_exc())
error_pic = os.path.join(common_function.get_current_dir(),
r'Test_Report', 'img',
'{}.png'.format(case_name))
capture_screen(error_pic)
os.system("wmctrl -c 'Control Panel'")
pass
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):
value_ls = get_defaule()
try:
log.info('Begin to start test {}'.format(case_name))
result_file = os.path.join(
common_function.get_current_dir(), r'Test_Report',
'{}.yaml'.format(common_function.check_ip_yaml()))
new_cases_result(result_file, case_name)
SwitchThinProMode(switch_to='admin')
source_pic1 = os.path.join(
common_function.get_current_dir(),
'Test_Data/td_power_manager/verify_screensaver_diff_image',
'source_pic/pic.jpg')
source_img1, source_size1 = open_pic(source_pic1)
source_data1 = get_pic_color(source_img1, get_xy(source_size1))
log.info('pic.jpg data {}'.format(source_data1))
source_pic2 = os.path.join(
common_function.get_current_dir(),
'Test_Data/td_power_manager/verify_screensaver_diff_image',
'source_pic/pic1.png')
source_img2, source_size2 = open_pic(source_pic2)
source_data2 = get_pic_color(source_img2, get_xy(source_size2))
log.info('pic1.png data {}'.format(source_data2))
power_m = PowerManagerFactory("ScreenSaver")
if not power_m.open_power_manager_from_control_panel():
log.info('try open power manager again')
power_m.open_power_manager_from_control_panel()
power_m.ScreenSaver.switch()
data1, data2 = step1(power_m, source_size1, source_size2)
log.info(f"data1 type: {type(data1)}")
log.info(f"source data1 type: {type(source_data1)}")
log.info([data1, data2])
log.info([source_data1, source_data2])
if [data1, data2] == [source_data1, source_data2] or [
data2, data1
] == [source_data1, source_data2]:
steps = {
'step_name': 'verify new slideshow',
'result': 'Pass',
'expect': 'slideshow',
'actual': 'slideshow',
'note': ''
}
update_cases_result(result_file, case_name, steps)
else:
log.debug(
"picture not match",
common_function.get_current_dir(
'Test_Report', 'img',
'{}_slideshow.png'.format(case_name.replace(' ', '_'))))
steps = {
'step_name': 'verify new slideshow',
'result': 'Fail',
'expect': 'slideshow',
'actual': 'no slideshow',
'note': ''
}
update_cases_result(result_file, case_name, steps)
reset_settings(value_ls)
return False
data3, data4 = step2(power_m)
log.info(f"data3 type: {type(data3)}")
log.info(f"source data1 type: {type(source_data1)}")
log.info([data3, data4])
log.info([source_data1, source_data2])
if [data3, data4] == [source_data1, source_data2] or [
data4, data3
] == [source_data1, source_data2]:
steps = {
'step_name': 'verify new slideshowstretch',
'result': 'Pass',
'expect': 'slideshowstrech',
'actual': 'slideshowstrech',
'note': ''
}
update_cases_result(result_file, case_name, steps)
else:
log.debug(
"picture not match",
common_function.get_current_dir(
'Test_Report', 'img', '{}_slideshowstretch.png'.format(
case_name.replace(' ', '_'))))
steps = {
'step_name': 'verify new slideshow',
'result': 'Fail',
'expect': 'slideshow',
'actual': 'no slideshowstrech',
'note': ''
}
update_cases_result(result_file, case_name, steps)
reset_settings(value_ls)
return False
if step3(power_m, 4):
steps = {
'step_name': 'verify new center show',
'result': 'Pass',
'expect': 'center',
'actual': 'center',
'note': ''
}
update_cases_result(result_file, case_name, steps)
else:
log.debug(
"picture not match",
common_function.get_current_dir(
'Test_Report', 'img',
'{}_center.png'.format(case_name.replace(' ', '_'))))
steps = {
'step_name': 'verify new center show',
'result': 'Fail',
'expect': 'center',
'actual': 'no center',
'note': ''
}
update_cases_result(result_file, case_name, steps)
locked_wake_up()
time.sleep(5)
reset_settings(value_ls)
return False
locked_wake_up()
time.sleep(5)
data = step4(power_m, source_size1)
if data == source_data1:
steps = {
'step_name': 'verify new expand show',
'result': 'Pass',
'expect': 'expand',
'actual': 'expand',
'note': ''
}
update_cases_result(result_file, case_name, steps)
else:
log.debug(
"picture not match",
common_function.get_current_dir(
'Test_Report', 'img',
'{}_expand.png'.format(case_name.replace(' ', '_'))))
steps = {
'step_name': 'verify new expand show',
'result': 'Fail',
'expect': 'expand',
'actual': 'no expand',
'note': ''
}
update_cases_result(result_file, case_name, steps)
reset_settings(value_ls)
return False
data5 = step5(power_m)
if data5 == source_data2:
steps = {
'step_name': 'verify new stretch show',
'result': 'Pass',
'expect': 'stretch',
'actual': 'stretch',
'note': ''
}
update_cases_result(result_file, case_name, steps)
else:
log.debug(
"picture not match",
common_function.get_current_dir(
'Test_Report', 'img',
'{}_stretch.png'.format(case_name.replace(' ', '_'))))
steps = {
'step_name': 'verify new stretch show',
'result': 'Fail',
'expect': 'stretch',
'actual': 'no stretch',
'note': ''
}
update_cases_result(result_file, case_name, steps)
reset_settings(value_ls)
return False
if step6(power_m, 7):
steps = {
'step_name': 'verify new tile show',
'result': 'Pass',
'expect': 'tile',
'actual': 'tile',
'note': ''
}
update_cases_result(result_file, case_name, steps)
else:
log.debug(
"picture not match",
common_function.get_current_dir(
'Test_Report', 'img',
'{}_tile.png'.format(case_name.replace(' ', '_'))))
steps = {
'step_name': 'verify new tile show',
'result': 'Fail',
'expect': 'tile',
'actual': 'no tile',
'note': ''
}
update_cases_result(result_file, case_name, steps)
locked_wake_up()
time.sleep(5)
reset_settings(value_ls)
return False
locked_wake_up()
time.sleep(5)
power_m.close_all_power_manager()
reset_settings(value_ls)
log.info('{} is end'.format(case_name))
except:
reset_settings(value_ls)
log.error(traceback.format_exc())
error_pic = os.path.join(common_function.get_current_dir(),
r'Test_Report', 'img',
'{}.png'.format(case_name.replace(' ', '_')))
capture_screen(error_pic)
os.popen("hptc-control-panel --term")
pass
