def add_wl(wireless, ssid, case_name, result_file):
log.info('start add wireless profile {}'.format(ssid))
wireless.add(ssid=ssid)
wireless.apply_and_ok()
icon = wait_element(wl_pic("_move_mouse"), offset=(0, 10))
tool.click(icon[0][0], icon[0][1], num=2)
if wait_element(wl_pic("_{}".format(ssid))):
log.info("wireless profile {} add success".format(ssid))
steps = {
'step_name': 'check all the configurations could be saved -- add',
'result': 'Pass',
'expect': '',
'actual': '',
'note': ''
}
update_cases_result(result_file, case_name, steps)
else:
error_pic = os.path.join(get_current_dir(), r'Test_Report', 'img',
'{}+add1.png'.format(case_name))
capture_screen(error_pic)
steps = {
'step_name': 'check all the configurations could be saved -- add',
'result': 'Fail',
'expect': 'saved',
'actual': 'no exists',
'note': '{}'.format(error_pic)
}
update_cases_result(result_file, case_name, steps)
wireless.wl_set_apply()
return False
wireless.wl_set_apply()
time.sleep(25)
if check_wl("add_res"):
log.info('new wireless profile connection success')
steps = {
'step_name':
'check could successful connect to specified AP -- add',
'result': 'Pass',
'expect': '',
'actual': '',
'note': ''
}
update_cases_result(result_file, case_name, steps)
else:
error_pic = os.path.join(get_current_dir(), r'Test_Report', 'img',
'{}+add2.png'.format(case_name))
capture_screen(error_pic)
steps = {
'step_name':
'check could successful connect to specified AP -- add',
'result': 'Fail',
'expect': 'connect',
'actual': 'disconnect',
'note': '{}'.format(error_pic)
}
update_cases_result(result_file, case_name, steps)
close_wl_statistics()
reset_setting(wireless, ssid)
return False
close_wl_statistics()
def delete_wl(wireless, ssid, case_name, result_file):
log.info('start delete wireless profile {}'.format(ssid))
wireless.delete(ssid=ssid)
icon = wait_element(wl_pic("_move_mouse"), offset=(0, 10))
tool.click(icon[0][0], icon[0][1], num=2)
if not wait_element(wl_pic("_{}".format(ssid))):
log.info("wireless profile {} delete success".format(ssid))
steps = {
'step_name': 'check selected profile could be deleted',
'result': 'Pass',
'expect': '',
'actual': '',
'note': ''
}
update_cases_result(result_file, case_name, steps)
else:
error_pic = os.path.join(get_current_dir(), r'Test_Report', 'img',
'{}+delete1.png'.format(case_name))
capture_screen(error_pic)
steps = {
'step_name': 'check selected profile could be deleted',
'result': 'Fail',
'expect': 'deleted',
'actual': 'exists',
'note': '{}'.format(error_pic)
}
update_cases_result(result_file, case_name, steps)
wireless.wl_set_apply()
reset_setting(wireless, ssid)
return False
wireless.wl_set_apply()
time.sleep(25)
if not check_wl("edit_res"):
log.info('deleted wireless connection disconnection success')
steps = {
'step_name':
'check thinpro will disconnect from the wireless network',
'result': 'Pass',
'expect': '',
'actual': '',
'note': ''
}
update_cases_result(result_file, case_name, steps)
else:
error_pic = os.path.join(get_current_dir(), r'Test_Report', 'img',
'{}+delete2.png'.format(case_name))
capture_screen(error_pic)
steps = {
'step_name':
'check thinpro will disconnect from the wireless network',
'result': 'Fail',
'expect': 'disconnect',
'actual': 'connect',
'note': '{}'.format(error_pic)
}
update_cases_result(result_file, case_name, steps)
close_wl_statistics()
reset_setting(wireless, ssid)
return False
close_wl_statistics()
def pic_cut(folder, name):
pic = os.path.join(
common_function.get_current_dir(),
'Test_Data/td_power_manager/verify_screensaver_diff_image',
'{}/{}.png'.format(folder, name))
capture_screen(pic)
return pic
def login_domain_user(*args, **kwargs):
case_name = kwargs.get("case_name")
result_file = kwargs.get("report_file")
log.info('2.1. Login with !#$%^ Shanghai2010')
time.sleep(10)
domain_login(user_name='!#$%^', password="******")
time.sleep(5)
if check_account('start') or check_account('domain_icon'):
steps = {
'step_name': 'login domain account success',
'result': 'Pass',
'expect': 'login success',
'actual': 'success',
'note': ''
}
common_function.update_cases_result(result_file, case_name, steps)
else:
error_pic = os.path.join(common_function.get_current_dir(),
r'Test_Report', 'img',
'login_domain_user_result.png')
picture_operator.capture_screen(error_pic)
steps = {
'step_name': 'login domain account success',
'result': 'Fail',
'expect': 'login success',
'actual': 'fail',
'note': '{}'.format(error_pic)
}
common_function.update_cases_result(result_file, case_name, steps)
reset_all_settings(num=0)
return False
def __update_result(self):
step = {
'step_name': '',
'result': 'PASS',
'expect': '',
'actual': '',
'note': ''
}
step.update({'step_name': self.event_method_name})
if not self.flag:
if self.capture:
path = get_current_dir(
"Test_Report/img/{}__{}_exception.png".format(
self.case_name, self.event_method_name))
log.warning(f"capture path: {path}")
capture_screen(path)
step.update({
'result':
'Fail',
'expect':
self.error_msg.get("expect", ""),
'actual':
self.error_msg.get("actual", ""),
'note':
'{}__{}_exception.png'.format(self.case_name,
self.event_method_name)
if self.capture else ""
})
else:
step.update(self.success_msg)
update_cases_result(self.yml_path, self.case_name, step)
return
def verify_two_account(*args, **kwargs):
case_name = kwargs.get("case_name")
result_file = kwargs.get("report_file")
log.info('verify two accounts art listed')
lock_screen()
if check_account('with_vdi'):
steps = {
'step_name': 'verify two accounts art listed',
'result': 'Pass',
'expect': 'correct',
'actual': 'correct',
'note': ''
}
common_function.update_cases_result(result_file, case_name, steps)
else:
error_pic = os.path.join(
common_function.get_current_dir(), r'Test_Report', 'img',
'verify_domain_and_rdp_two_account_are_listed.png')
picture_operator.capture_screen(error_pic)
steps = {
'step_name': 'verify two accounts art listed',
'result': 'Fail',
'expect': 'correct',
'actual': 'wrong',
'note': ''
}
common_function.update_cases_result(result_file, case_name, steps)
reset_all_settings(num=0)
return False
def add_domain_result(*args, **kwargs):
log.info('check the result of step join tc domain')
case_name = kwargs.get("case_name")
result_file = kwargs.get("report_file")
if check_icon('domain_login_user') or check_icon('domain_login_pwd'):
steps = {
'step_name': 'verify add domain and reboot success',
'result': 'Pass',
'expect': 'add domain success',
'actual': 'success',
'note': ''
}
common_function.update_cases_result(result_file, case_name, steps)
else:
error_pic = os.path.join(common_function.get_current_dir(),
r'Test_Report', 'img',
'verify_add_domain_result.png')
picture_operator.capture_screen(error_pic)
steps = {
'step_name': 'verify add domain and reboot success',
'result': 'Fail',
'expect': 'add domain success',
'actual': 'fail',
'note': '{}'.format(error_pic)
}
common_function.update_cases_result(result_file, case_name, steps)
domain_login(user_name='!#$%^', password="******")
reset_all_settings(num=0)
return False
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 verify_cpu_mhz(mode, case_name, power_manager):
try:
if mode == 'ondemand':
low_mhz = linux_get_cpu_mhz(mode)
select_mode('performance', power_manager)
time.sleep(15)
high_mhz = linux_get_cpu_mhz('performance')
log.info("ondemand mode:{}, performance mode:{}".format(
low_mhz, high_mhz))
return [high_mhz, low_mhz]
else:
high_mhz = linux_get_cpu_mhz(mode)
select_mode('ondemand', power_manager)
time.sleep(15)
low_mhz = linux_get_cpu_mhz('ondemand')
log.info("performance mode:{}, ondemand mode:{}".format(
high_mhz, low_mhz))
return [high_mhz, low_mhz]
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'")
return '0'
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 step2(case_name):
try:
return check_icon('default')
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)
return
def step1(*args, **kwargs):
case_name = kwargs.get("case_name")
report_file = kwargs.get("report_file")
SwitchThinProMode(switch_to='admin')
log.info('set user password: 1')
set_user_password()
log.info('enable require password for general users')
power_m = PowerManagerFactory("ScreenSaver")
power_m.ScreenSaver.open_power_manager_from_control_panel()
power_m.ScreenSaver.switch()
power_m.ScreenSaver.set(
pms=pms.ScreenSaver.Enable_Screensaver_and_Screen_Lock, radio="on")
power_m.ScreenSaver.set(
pms=pms.ScreenSaver.Require_password_for_general_users, radio="on")
click_icon('ok', count=1)
power_m.ScreenSaver.apply()
time.sleep(5)
power_m.ScreenSaver.close_all_power_manager()
SwitchThinProMode(switch_to='user')
log.info('start a web connection')
web = WebConn([])
web.open_firefox()
if click_icon('firefox_title'):
log.info('web connection success')
lock_screen()
pyautogui.press('enter')
if click_icon('locked_dialog'):
log.info('screen lock dialog shown')
steps = {
'step_name': "verify screen lock dialog shown",
'result': 'Pass',
'expect': 'show',
'actual': 'show',
'note': ''
}
common_function.update_cases_result(report_file, case_name, steps)
else:
error_pic = os.path.join(
common_function.get_current_dir(), r'Test_Report', 'img',
'{}+step1.png'.format(case_name.replace(' ', '_')))
capture_screen(error_pic)
steps = {
'step_name': "verify screen lock dialog shown",
'result': 'Fail',
'expect': 'show',
'actual': 'not show',
'note': ''
}
common_function.update_cases_result(report_file, case_name, steps)
reset_settings()
return False
def check_layout(source):
temp_pic = picture_operator.capture_screen(os.path.join(common_function.get_current_dir(), 'temp.png'), auto_fix=True)
if temp_pic:
flag = False
if not os.path.exists(source):
flag = True
return [*picture_operator.compare_picture_auto_collect(temp_pic, source, auto_fix=True), flag]
def wrapper(*args, **kwargs):
try:
return func(*args, **kwargs)
except LogonError:
traceback.print_exc()
white_list = None
cs = ""
if args:
vdi = args[0].__class__.__name__.lower()
if "rdp" in vdi:
white_list = white_list_rdp
elif "view" in vdi:
white_list = white_list_view
elif "citrix" in vdi:
white_list = white_list_citrix
except_pic_path = "{}/Test_Report".format(cf.get_current_dir())
if not os.path.exists(except_pic_path):
os.makedirs(except_pic_path)
cs = capture_screen(except_pic_path + "/{}_exception.png".format(vdi))
flag = False
if white_list:
self = args[0]
for k, v in white_list.items():
if v and k.lower() == "pic":
flag = self.check_picture(v, cs)
if flag:
raise Continue
else:
raise LogonError
def step1(case_name):
try:
power_m = PowerManagerFactory("ScreenSaver")
power_m.ScreenSaver.open_power_manager_from_control_panel()
power_m.ScreenSaver.switch()
before = check_changed('activation')
set_system_image(power_m)
time.sleep(5)
after = check_changed('activation1')
power_m.ScreenSaver.close_all_power_manager()
if before and after:
return True
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)
return []
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 verify_remote_only(*args, **kwargs):
case_name = kwargs.get("case_name")
result_file = kwargs.get("report_file")
user = kwargs.get('user')
conn = kwargs.get('conn')
start_remote('', conn=conn)
time.sleep(5)
log.info("verify only remote session's account is listed")
require_pass_domain_users()
SwitchThinProMode(switch_to='user')
start_remote('logon', conn=conn)
lock_screen()
if check_account('no_vdi'):
steps = {
'step_name': "only one remote session's account is listed",
'result': 'Pass',
'expect': 'success',
'actual': 'success',
'note': ''
}
common_function.update_cases_result(result_file, case_name, steps)
unlock_screen(r'sh\{}'.format(user), 'Shanghai2010')
else:
error_pic = os.path.join(common_function.get_current_dir(),
r'Test_Report', 'img',
'{}+verify_remote_only.png'.format(case_name))
picture_operator.capture_screen(error_pic)
steps = {
'step_name': "only one remote session's account is listed",
'result': 'Fail',
'expect': 'success',
'actual': 'fail',
'note': '{}'.format(error_pic)
}
common_function.update_cases_result(result_file, case_name, steps)
unlock_screen(r'sh.dto\!#$%^', 'Shanghai2010')
start_remote('', conn=conn)
def event(event_method, *args, **kwargs):
event_method_name = event_method.__name__
step = {'step_name': '',
'result': 'PASS',
'expect': '',
'actual': '',
'note': ''}
case_name = kwargs.get("case_name")
yml_path = kwargs.get("yml_path", "")
assert yml_path != "", 'yml_path error'
event_params, event_dic = kwargs.get("event_params", ((), {}))
call_back = kwargs.get("call_back", None)
callback_params, callback_dic = kwargs.get("callback_parmas", ((), {}))
inherit = kwargs.get("inherit", False)
do_callback = kwargs.get("do_call_back", True)
do_callback_false = kwargs.get("do_call_back_while_fail", False)
res = event_method(*event_params, **event_dic)
flag = True if res else False
step.update({'step_name': event_method_name})
if not res:
path = common_function.get_current_dir("Test_Report/img/{}__{}_exception.png".format(case_name.replace(' ', '_'), event_method_name))
picture_operator.capture_screen(path)
error_msg = kwargs.get("error_msg", {})
step.update({'result': 'Fail',
'expect': error_msg.get("expect", ""),
'actual': error_msg.get("actual", ""),
'note': '{}_exception.png'.format(event_method_name)})
common_function.update_cases_result(yml_path, case_name, step)
if do_callback and flag:
if inherit and res:
call_back(res, **callback_dic)
elif call_back:
print(*callback_params)
call_back(*callback_params, **callback_dic)
elif do_callback_false and not res:
call_back(*callback_params, **callback_dic)
return flag
def step2(*args, **kwargs):
case_name = kwargs.get("case_name")
report_file = kwargs.get("report_file")
unlock_screen1('0')
a = click_icon('error')
time.sleep(5)
pyautogui.press('enter')
time.sleep(1)
unlock_screen1('1')
b = click_icon('error')
c = click_icon('locked_dialog')
if a and not b and not c:
steps = {
'step_name': "verify screen can be resumed successfully",
'result': 'Pass',
'expect': 'success',
'actual': 'success',
'note': ''
}
common_function.update_cases_result(report_file, case_name, steps)
else:
error_pic = os.path.join(
common_function.get_current_dir(), r'Test_Report', 'img',
'{}+step2.png'.format(case_name.replace(' ', '_')))
capture_screen(error_pic)
steps = {
'step_name': "verify screen can be resumed successfully",
'result': 'Fail',
'expect': 'success',
'actual': 'fail',
'note': ''
}
common_function.update_cases_result(report_file, case_name, steps)
unlock_screen('root', '1')
reset_settings()
return False
def into_admin(back=False):
response1 = check_object_exist("all.png", back=back)
response2 = check_object_exist("admin_password.png",
offset=(60, 10),
back=back)
if response1:
rs, shape = response1
click(*rs)
type_string("1")
tap_key(keyboard.tab_key, 1)
type_string("1")
tap_key(keyboard.enter_key)
elif response2:
rs, shape = response2
click(*rs)
type_string("1", 0.5)
tap_key(keyboard.enter_key)
else:
path = get_root_path("Test_Report/img", back=back)
if not os.path.exists(path):
os.mkdir(path)
capture_screen(
get_root_path("Test_Report/img/error_admin.jpg", back=back))
return
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):
SwitchThinProMode(switch_to='admin')
name = check_powerpic.__name__
# ip = get_ip()
# ip = check_ip_yaml()
# pathyml = get_root_path("Test_Report/{}.yaml".format(ip))
base_name = get_report_base_name()
pathyml = get_current_dir('Test_Report', base_name)
new_cases_result(pathyml, case_name)
estart_position = check_powerpic()
flag = False
with os.popen('/usr/bin/hptc-hwsw-id --hw') as f:
rs = f.read()
if rs:
rs = rs.lower()
if 't630' in rs or 't730' in rs:
with os.popen('ethtool eth0') as fl:
res = fl.read()
if res:
if 'fibre' in res.lower():
flag = True
else:
with os.popen("ifconfig") as fl2:
r = fl2.read()
r = r.lower() if r else r
if 'eth0' in r and 'eth1' in r.lower():
flag = True
if estart_position is not None and flag == False:
steps = {'step_name': name,
'result': 'PASS',
'expect': '', # can be string or pic path
'actual': '', # can be string or pic path
'note': ''}
print("success")
elif estart_position is None and flag == True:
steps = {'step_name': name,
'result': 'PASS',
'expect': 'no estarlogo', # can be string or pic path
'actual': 'no estarlogo', # can be string or pic path
'note': 'no estarlogo beacuse of tp with fibre'}
print("success")
else:
path = get_root_path("Test_Report/img")
if not os.path.exists(path):
os.mkdir(path)
picture_operator.capture_screen(get_root_path("Test_Report/img/{}.jpg".format(name)))
steps = {'step_name': name,
'result': 'Fail',
'expect': '', # can be string or pic path
'actual': 'img/{}.jpg'.format(name), # can be string or pic path
'note': ''}
print("fail")
update_cases_result(pathyml, case_name, steps)
try:
pathclose = get_root_path("Test_Data/td_precheck/Thinpro7.1/{}".format("power_close.png"))
rs = picture_operator.wait_element(pathclose, 1, (3, 3))[0]
click(*rs)
except AssertionError as e:
print(e)
except Exception as f:
print(f)
def events(testevent,
params=None,
callbacktest=None,
cbparams=None,
assertion=True,
annotation=None,
case_name='check_edocs_app'):
"""
involve two test that if you want to execute some functions like a serious of events
the method contains a event of logging yaml result
:param testevent: function, a check test mainly;return a tuple((x,y),(x,y,z))
:param params: string , a test pic name
:param callbacktest: function
:param cbparams:string,we offer a "fromtest" string for you to get the result return from testevent
:param assertion:boolean that you estimate your result
:param annotation:tuple:(funcname,picname) if fail, you can customise your error info into yaml note and console
eg.
:return:
"""
testname = testevent.__name__
testparams = testevent(params)
paramsname = params.split(".")[0]
steps = {
'step_name': testname,
'result': 'PASS',
'expect': "", # can be string or pic path
'actual': '', # can be string or pic path
'note': ""
}
if annotation:
length = len(annotation)
if callbacktest:
if length == 2:
a, b = annotation
notes = "error in {}, events({},{}) : {}".format(
a, testname, params, b)
elif length == 1:
a = annotation[0]
notes = "error in {}, events({},{}) : can't find {}".format(
a, testname, params, paramsname)
else:
notes = "error ! ,events({},{})".format(testname, params)
else:
if length == 2:
a, b = annotation
notes = "error in {}, events({},{}) : {}".format(
a, testname, params, b)
elif length == 1:
a = annotation[0]
notes = "error in {}, events({},{}) : {} can't work or not matched".format(
a, testname, params, paramsname)
else:
notes = "error in, events({},{})".format(testname, params)
else:
notes = "error, events({},{}) ".format(testname, params)
flag = True if testparams else False
try:
assert flag == assertion, notes
print(testname, testparams, assertion, flag)
if callbacktest:
if cbparams.lower() == "fromtest":
return callbacktest(testparams)
else:
return callbacktest(cbparams)
except AssertionError as e:
print(testname, testparams, assertion, flag)
tname = "{}-{}".format(testname, params)
path = get_root_path("Test_Report/img")
if not os.path.exists(path):
os.mkdir(path)
capture_screen(get_root_path("Test_Report/img/{}.jpg".format(tname)))
steps['result'] = "Fail"
steps['actual'] = 'img/' + tname
steps['note'] = notes
raise AssertionError(notes + "???")
finally:
ip = get_ip()
# path = get_root_path("Test_Report/{}.yaml".format(ip))
base_name = get_report_base_name()
path = get_current_dir('Test_Report', base_name)
update_cases_result(path, case_name, steps)
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))
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 error_snapshot(pic_name):
pic = datetime.datetime.today().strftime('%Y-%m-%d_%H-%M-%S') + '_' + pic_name + '.jpg'
name = os.path.join(cf.get_current_dir(), 'Test_Report', pic)
capture_screen(name)
def main():
# show_desktop()
if os.path.exists(get_current_dir('flag.txt')):
with open(get_current_dir('flag.txt')) as f:
test_flag = f.read()
if 'TEST FINISHED' in test_flag.upper():
return
if not os.path.exists('time.txt'):
with open('time.txt', 'w') as f:
f.write(time.ctime())
prepare_for_framework()
additional_path = get_current_dir('Test_Data', 'additional.yml')
file_obj = YamlOperator(additional_path)
content = file_obj.read()
site = content.get('AutoDash_Site')
if not site:
load_data_from_ftp()
script_name = os.path.basename(__file__).split('.')[0]
add_linux_script_startup([script_name])
check_water_mark()
path = get_current_dir('reboot.txt')
if not os.path.exists(path):
with open(path, 'w+') as f:
f.write("0")
time.sleep(5)
if os.path.exists(path):
SwitchThinProMode("admin")
os.popen('reboot')
time.sleep(30)
if not os.path.exists(get_current_dir('Test_Report')):
os.mkdir(get_current_dir('Test_Report'))
test_data_path = os.path.join(get_current_dir(), 'Test_Data')
with open(get_current_dir('flag.txt'), 'w') as f:
f.write('testing')
if not os.path.exists(os.path.join(test_data_path, 'script.yml')):
log.info('script.yml not exist, please check if no cases planned')
with open(get_current_dir('flag.txt'), 'w') as f:
f.write('test finished')
return
with open(os.path.join(test_data_path, 'script.yml'), 'r') as f:
scripts = yaml.safe_load(f)
with open(os.path.join(test_data_path, 'additional.yml'), 'r') as f:
additional = yaml.safe_load(f)
for script in scripts:
script_name, script_status = list(script.items())[0]
if script_status.upper() == 'NORUN':
log.info('Begin to Test case {}'.format(script_name))
try:
if need_reboot() == 1:
change_reboot_status(0)
reboot_command()
memory_check(limit=MEMORY_LIMIT)
globals()[script_name.split('__')[0]].start(
case_name=script_name.split('__')[1], kwargs=additional)
script[script_name] = 'Finished'
with open(os.path.join(test_data_path, 'script.yml'),
'w') as f:
yaml.safe_dump(scripts, f)
except MemoryNotSufficient as e:
log.debug(e)
log.debug("start reboot")
reboot_command()
except:
with open(get_current_dir('Test_Report', 'debug.log'),
'a') as f:
f.write(traceback.format_exc())
capture_screen(
get_current_dir(
'Test_Report',
'img',
'{}.jpg'.format(script_name.split('__')[1]),
))
script[script_name] = 'Finished'
with open(os.path.join(test_data_path, 'script.yml'),
'w') as f:
yaml.safe_dump(scripts, f)
steps = {
'step_name': 'case exception',
'result': 'Fail',
'expect': '', # can be string or pic path
'actual': 'img/{}.jpg'.format(script_name.split('__')[1]),
'note': traceback.format_exc()
}
base_name = get_report_base_name()
report_file = get_current_dir('Test_Report', base_name)
# result_file = get_current_dir(r'Test_Report', '{}.yaml'.format(check_ip_yaml()))
update_cases_result(report_file,
script_name.split('__')[1], steps)
else:
log.info('Test case {} status is Finished, Skip test'.format(
script_name))
if os.path.exists(path):
if need_reboot() == 0:
change_reboot_status(9)
log.info("Start Reboot before Report")
reboot_command()
else:
os.remove(path)
if site:
share_folder = content.get('share_folder')
host = share_folder.split('/')[0]
folder_path = '/'.join(share_folder.split('/')[1:])
user = content.get('user')
password = content.get('password')
flag_path = '/{}/{}.txt'.format(folder_path, site)
log.info('end_flag: {}'.format(flag_path))
with open(get_current_dir('{}.txt'.format(site)), 'w') as f:
f.write('test finished')
ftp = FTPUtils(host, user, password)
ftp.ftp.cwd('ThinPro_Automation_Site')
local_folder = get_current_dir('Test_Report')
ftp_folder = r'/{}/Test_Report'.format(folder_path)
num = 0
while True:
try:
ftp = FTPUtils(host, user, password)
log.info('upload Test_Report folder to ftp')
log.info(local_folder)
log.info(ftp_folder)
ftp.new_dir(ftp_folder)
local_report = get_current_dir('Test_Report',
'{}.yaml'.format(site))
ftp_report = '/{}/Test_Report/{}.yaml'.format(
folder_path, site)
ftp.upload_file(local_report, ftp_report)
ftp.upload_file(get_current_dir(r"{}.txt".format(site)),
flag_path)
break
except:
if num > 30:
traceback.print_exc()
break
else:
num += 5
time.sleep(5)
else:
with open(get_current_dir('flag.txt'), 'w') as f:
f.write('test finished')
with open('time.txt') as f:
start = f.read()
end = time.ctime()
report = email_tool.GenerateReport(start, end)
report.generate()
file = email_tool.zip_dir()
log.info('zipped file name: {}'.format(file_obj))
additional_email = additional.get('email') if additional.get(
'email') else ''
email_tool.send_mail(
recipient=['*****@*****.**', additional_email],
subject='Automation Report Linux {}'.format(
zip_file_name(get_report_number(), get_report_value())),
attachment=file)
os.remove(file)
os.remove('time.txt')
try:
collect_report()
except Exception as e:
print(e)
log.error(e)
if cbparams.lower() == "fromtest":
return callbacktest(testparams)
else:
return callbacktest(cbparams)
except AssertionError as e:
print(testname, testparams, assertion, flag)
tname = "{}-{}".format(testname, params)
path = get_root_path("Test_Report/img")
if not os.path.exists(path):
os.mkdir(path)
capture_screen(get_root_path("Test_Report/img/{}.jpg".format(tname)))
steps['result'] = "Fail"
steps['actual'] = 'img/' + tname
steps['note'] = notes
raise AssertionError(notes + "???")
finally:
ip = get_ip()
# path = get_root_path("Test_Report/{}.yaml".format(ip))
base_name = get_report_base_name()
path = get_current_dir('Test_Report', base_name)
update_cases_result(path, case_name, steps)
return True
if __name__ == '__main__':
path = get_root_path("Test_Report/img")
if not os.path.exists(path):
os.mkdir(path)
capture_screen(get_root_path("Test_Report/img/{}.jpg".format("name")))
print("")
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
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
