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 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 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 login_remote(*args, **kwargs):
case_name = kwargs.get("case_name")
result_file = kwargs.get("report_file")
log.info('2.2. Start a remote session with your SH account.')
SwitchThinProMode(switch_to='user')
conn = kwargs.get('conn')
if start_remote('logon', conn=conn):
steps = {
'step_name': 'login a remote session (RDP)',
'result': 'Pass',
'expect': '',
'actual': '',
'note': ''
}
common_function.update_cases_result(result_file, case_name, steps)
else:
log.info('remote session login fail')
steps = {
'step_name': 'login a remote session (RDP)',
'result': 'Fail',
'expect': 'login success',
'actual': 'vdi login fail',
'note': ''
}
common_function.update_cases_result(result_file, case_name, steps)
reset_all_settings(num=0)
return False
def set_proxy_common(proxy_test, proxy_server, case_name, report_file):
protocol_name = proxy_test.protocol
msg = 'step - - set {} proxy to {}'.format(protocol_name, proxy_server)
log.info(msg)
steps = {
'step_name': '',
'result': '',
'expect': '',
'actual': '',
'note': ''
}
if proxy_test.set_proxy(proxy_server):
step_rs = 'Pass'
fun_rs = True
msg2 = 'succeed to clear http proxy'
else:
step_rs = 'Fail'
fun_rs = False
msg2 = 'Failed to clear http proxy'
msg3 = 'network panel can be edit'
steps['step_name'] = msg
steps['actual'] = msg2
steps['expect'] = msg3
steps['result'] = step_rs
log.info('test {}'.format(step_rs))
common_function.update_cases_result(report_file, case_name, steps)
# if fun_rs:
# proxy_test.reboot()
# else:
# proxy_test.reset_env_halfway()
return fun_rs
def dynamic_ip_check(case_name, result_file, wired):
log.info("set connection method -> automatic")
wired.open_network_wired_dialog()
wired.set_dynamic_ip()
time.sleep(5)
log.info("open network wired check current connection method")
wired.open_network_wired_dialog()
res = wait_element(case_pic("connection_method", ip_mode='dynamic'))
if res:
steps = {
'step_name': 'check dynamic connection method set success',
'result': 'Pass',
'expect': '',
'actual': '',
'note': ''
}
update_cases_result(result_file, case_name, steps)
else:
method = get_connection_method()
steps = {
'step_name': 'check dynamic connection method set success',
'result': 'Fail',
'expect': '',
'actual': 'the connection method automatic',
'note': 'connection method {}'.format(method)
}
update_cases_result(result_file, case_name, steps)
wired.close_control_panel()
return False
wired.close_control_panel()
def step_check_user_in_credential_list(self, in_list, report_file,
case_name):
flag = False
user_in = self.wait_pictures("_user_of_credentials")
if user_in and in_list:
step = {
'step_name': 'Check user in credential list',
'result': 'Pass',
'expect': 'User should be in credential list.',
'actual': 'User is in credential list.',
'note': 'none'
}
flag = True
elif not user_in and not in_list:
step = {
'step_name': 'Check user not in credential list',
'result': 'Pass',
'expect': 'User should not be in credential list.',
'actual': 'User is not in credential list.',
'note': 'none'
}
flag = True
else:
step = {
'step_name': 'Check whether user in credential list or not',
'result': 'Fail',
'expect': '',
'actual': 'Fail.',
'note': 'none'
}
common_function.update_cases_result(report_file, case_name, step)
return flag
def step5_res(*args, **kwargs):
case_name = kwargs.get("case_name")
report_file = kwargs.get("report_file")
with open(path, 'r', encoding='utf-8') as f:
file_info = f.readline()
print(file_info)
time.sleep(5)
time_gap = time.time() - float(file_info)
log.info('tc power off time is {}'.format(time_gap))
os.remove(path)
if time_gap > 5:
log.info('power off success')
steps = {
'step_name':
"verify screen can be unlocked and shutdown immediately",
'result': 'Pass',
'expect': 'success',
'actual': 'success',
'note': ''
}
common_function.update_cases_result(report_file, case_name, steps)
else:
steps = {
'step_name':
"verify screen can be unlocked and shutdown immediately",
'result': 'Fail',
'expect': 'success',
'actual': 'fail',
'note': ''
}
common_function.update_cases_result(report_file, case_name, steps)
reset_settings()
return False
def enable_wireless(*args, **kwargs):
report_file = kwargs.get("report_file")
case_name = kwargs.get("case_name")
step_2_result = step_2_1()
if not step_2_result[0]:
step_2_report = {
'step_name': 'step_2 enable wireless',
'result': 'Fail',
'expect': "enable wireless success",
'actual': "enable wireless fail",
'note': '{}'.format(step_2_result[1])
}
cf.update_cases_result(report_file, case_name, step_2_report)
restore()
restore_wireless()
log.error("{:+^80}".format("test case fail"))
return False
step_2_report = {
'step_name': 'step_2 enable wireless',
'result': 'Pass',
'expect': "enable wireless success",
'actual': "enable wireless success",
'note': '{}'.format(step_2_result[1])
}
cf.update_cases_result(report_file, case_name, step_2_report)
os.system("reboot")
time.sleep(60)
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 access_website_before(proxy_test, case_name, report_file):
msg = 'step - - access website before setting proxy'
log.info(msg)
steps = {
'step_name': '',
'result': '',
'expect': '',
'actual': '',
'note': ''
}
url = proxy_test.host_name
if not proxy_test.access_website():
step_rs = 'Pass'
fun_rs = True
msg2 = 'failed to access {}'.format(url)
else:
step_rs = 'Fail'
fun_rs = False
msg2 = 'succeed to access {}'.format(url)
msg3 = '{} can not be accessed'.format(url)
steps['step_name'] = msg
steps['actual'] = msg2
steps['expect'] = msg3
steps['result'] = step_rs
log.info('test {}'.format(step_rs))
common_function.update_cases_result(report_file, case_name, steps)
# if fun_rs:
# proxy_test.reboot()
# else:
# proxy_test.reset_env_halfway()
return fun_rs
def start(case_name, **kwargs):
SwitchThinProMode(switch_to='admin')
# report_file = network_function.system_ip() + '.yaml'
# ip = common_function.check_ip_yaml()
# report_file = get_root_path("Test_Report/{}.yaml".format(ip))
base_name = get_report_base_name()
report_file = get_current_dir('Test_Report', base_name)
common_function.new_cases_result(report_file, case_name) # new report
configure_check = ConfigureCheck()
result = configure_check.check()
if result == 'pass':
step1 = {
'step_name': 'Check smartzero configuration',
'result': 'Pass',
'expect': 'smartzero',
'actual': 'smartzero',
'note': 'none'
}
elif result == 'NA':
step1 = {
'step_name': 'Check smartzero configuration',
'result': 'Fail',
'expect': 'current os',
'actual': 'current os is not smartzero',
'note': 'none'
}
else:
step1 = {
'step_name': 'Check smartzero configuration',
'result': 'Fail',
'expect': 'smartzero',
'actual': 'fail to get target os',
'note': 'none'
}
common_function.update_cases_result(report_file, case_name, step1)
def clear_proxy(proxy_test, case_name, report_file):
protocol_name = proxy_test.protocol
msg = 'step - - clear {} proxy'.format(protocol_name)
log.info(msg)
steps = {
'step_name': '',
'result': '',
'expect': '',
'actual': '',
'note': ''
}
if proxy_test.set_proxy(''):
step_rs = 'Pass'
fun_rs = True
msg2 = 'succeed to clear proxy'
else:
step_rs = 'Fail'
fun_rs = False
msg2 = 'Failed to clear proxy'
msg3 = 'network panel can be edit'
steps['step_name'] = msg
steps['actual'] = msg2
steps['expect'] = msg3
steps['result'] = step_rs
log.info('test {}'.format(step_rs))
common_function.update_cases_result(report_file, case_name, steps)
return fun_rs
def step_unlock_result(self,
report_file,
case_name,
unlock_result='win10'):
if self.check_unlock_result(unlock_result):
step = {
'step_name': 'Check unlock result for vdi view',
'result': 'Pass',
'expect': 'Unlock vdi view successfully.',
'actual': 'Unlock vdi view successfully.',
'note': 'none'
}
common_function.update_cases_result(report_file, case_name, step)
return True
else:
self.log.debug(
'Fail to unlock vdi view',
common_function.get_current_dir("Test_Report", 'img',
'unlock_vdi_view_result.png'))
step = {
'step_name': 'Check unlock result for vdi view',
'result': 'Fail',
'expect': 'Unlock vdi view successfully.',
'actual': 'Fail to unlock vdi view.',
'note': 'none'
}
common_function.update_cases_result(report_file, case_name, step)
return False
def enable_wireless_after_reboot(**kwargs):
report_file = kwargs.get("report_file")
case_name = kwargs.get("case_name")
after_reboot_result = step_2_2()
if not after_reboot_result[0]:
step_2_report = {
'step_name': 'step_2 enable wireless',
'result': 'Fail',
'expect': "enable wireless success",
'actual': "enable wireless fail",
'note': '{}'.format(after_reboot_result[1])
}
cf.update_cases_result(report_file, case_name, step_2_report)
restore()
restore_wireless()
log.error("{:+^80}".format("test case fail"))
return False
step_2_report = {
'step_name': 'step_2 enable wireless',
'result': 'Pass',
'expect': "enable wireless success",
'actual': "enable wireless success",
'note': '{}'.format(after_reboot_result[1])
}
cf.update_cases_result(report_file, case_name, step_2_report)
restore()
log.info("{:+^80}".format("test case pass"))
return True
def step_unlock_result(self,
report_file,
case_name,
unlock_result='win10'):
if self.check_unlock_result(unlock_result):
step = {
'step_name': 'Check unlock result for vdi rdp',
'result': 'Pass',
'expect': 'Unlock vdi rdp successfully.',
'actual': 'Unlock vdi rdp successfully.',
'note': 'none'
}
common_function.update_cases_result(report_file, case_name, step)
return True
else:
rdp_id = self.vdi.vdi_connection_id('freerdp')[0]
share_credential = subprocess.getoutput(
"mclient --quiet get root/ConnectionType/freerdp/connections/{}/SingleSignOn"
.format(rdp_id))
step = {
'step_name':
'Check unlock result for vdi rdp',
'result':
'Fail',
'expect':
'Unlock vdi rdp successfully.',
'actual':
'Fail to unlock vdi rdp.',
'note':
'share credentials with screensaver: {}'.format(
share_credential)
}
common_function.update_cases_result(report_file, case_name, step)
return False
def website_test(self, url, flag, case_name, report_file):
if flag:
expect = 200
msg = "verify {} can be accessed".format(url)
else:
expect = 'Error'
msg = "verify {} can not be accessed".format(url)
steps = {
'step_name': "test {}".format(url),
'result': '',
'expect': 'status code should be {}'.format(expect),
'actual': '',
'note': ''
}
log.info(msg)
log.info('current ip: {}'.format(common_function.get_ip()))
log.info('get status code from {}'.format(url))
data = self.get_website_response()
actual = 'status code is {}'.format(data)
log.info(actual)
if data == expect:
s = 'Pass'
rs = True
else:
s = 'Fail'
rs = False
log.info('test {}'.format(s))
steps['result'] = s
steps['actual'] = actual
common_function.update_cases_result(report_file, case_name, steps)
return rs
def local_start(case_name, result_file, test_data, local_pic_name):
"""
make sure mouse position will not affect testing
"""
pic_min_sim = 0.99
x, y = mouse.position()
if x >= y > 200:
pyautogui.moveTo(200, 200)
elif 200 > x >= y:
pyautogui.moveTo(x + 20, y + 20)
else:
pyautogui.moveTo(250, 250)
time.sleep(20)
# check local resolution
pic_sim, diff_res, first_collect_flag = check_layout(os.path.join(test_data, 'td_multiple_display', 'local_pic', local_pic_name))
if "1_ms" in local_pic_name:
log.info("Change Sim to 0.93")
pic_min_sim = 0.93
if pic_sim >= pic_min_sim:
steps = {
'step_name': 'check local layout',
'result': 'Pass',
'expect': 'similarity > 99%', # can be string or pic path
'actual': 'layout and resolution set correctly',
'note': ''}
common_function.update_cases_result(result_file, case_name, steps)
return True, first_collect_flag
else:
if not os.path.exists(common_function.get_current_dir('Test_Report', 'img')):
os.mkdir(common_function.get_current_dir('Test_Report', 'img'))
try:
common_function.check_free_memory()
picture_operator.save_from_data('{}'.format(common_function.get_current_dir('Test_Report', 'img',
'{}.png'.format(case_name))),
diff_res)
save_path = common_function.get_current_dir('Test_Report', 'img', '{}.jpg'.format(case_name))
shutil.copy(common_function.get_current_dir('temp.png'),
save_path)
common_function.check_free_memory("after")
except AssertionError as e:
raise e
except:
save_fail_path = common_function.get_current_dir('Test_Report', 'img', 'save_fail_{}.txt'.format(case_name))
f = open(save_fail_path, "w")
f.close()
finally:
log.debug(gc.garbage)
gc.collect()
steps = {
'step_name': 'check local layout',
'result': 'Fail',
'expect': 'similarity > 99%', # can be string or pic path
'actual': 'img/{}.png'.format(case_name), # can be string or pic path
'note': 'actual similarity: {}'.format(pic_sim)}
common_function.update_cases_result(result_file, case_name, steps)
return False, first_collect_flag
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)
base_name = cf.get_report_base_name()
report_file = get_current_dir('Test_Report', base_name)
cf.new_cases_result(report_file, case_name) # new report
log.info("{:-^80}".format("start a case test"))
log.info("case name:" + case_name)
"""Get the image_id and sp in the yaml file"""
t = cf.load_global_parameters()
image_id = t.get("image_id")
sp = t.get("sp")
"""Get the system version number"""
version_id = subprocess.getoutput("cat /etc/imageid")
version = subprocess.getoutput("dpkg -l | grep hptc-sp-thinpro.*-sp")
if not version:
log.info("version number is a empty")
version_number = ''
else:
version_number = "".join(
subprocess.getoutput(
"dpkg -l | grep hptc-sp-thinpro.*-sp").replace(
" ", "").split("-")[3][0:6].split("."))[2:]
if image_id.upper() == version_id.upper() and sp == version_number:
log.info(
"version_id and version_number are the same as image_id and sp")
report = {
'result':
'Pass',
'expect':
"version_id and version_number are the same as image_id and sp",
'actual':
"version_id {0} and version_number {1} are the same as image_id {2} and sp {3}"
.format(version_id, version_number, image_id, sp),
'note':
''
}
cf.update_cases_result(report_file, case_name, report)
return True
else:
log.error(
"version_id and version_number are different from image_id and sp"
)
report = {
'result':
'Fail',
'expect':
"version_id and version_number are different from image_id and sp",
'actual':
"version_id {0} and version_number {1} are different from image_id {2} and sp {3}"
.format(version_id, version_number, image_id, sp),
'note':
''
}
cf.update_cases_result(report_file, case_name, report)
return False
def start(case_name, **kwargs):
common_function_tp.SwitchThinProMode(switch_to='admin')
# report_file = network_function.system_ip() + '.yaml'
# ip = common_function.check_ip_yaml()
# report_file = get_root_path("Test_Report/{}.yaml".format(ip))
base_name = get_report_base_name()
report_file = get_current_dir('Test_Report', base_name)
common_function.new_cases_result(report_file, case_name) # new report
check_storage = CheckStorage()
primary_result = check_storage.check_image_in_primary_disk()
if primary_result is True:
step1 = {
'step_name': 'Check whether image installed in primary disk',
'result': 'Pass',
'expect': 'in primary disk',
'actual': 'in primary disk',
'note': 'none'
}
elif primary_result == 'fail':
step1 = {
'step_name': 'Check whether image installed in primary disk',
'result': 'Fail',
'expect': 'in primary disk',
'actual':
'Fail to get primary card label or fail to get current primary card size',
'note': 'none'
}
else:
step1 = {
'step_name': 'Check whether image installed in primary disk',
'result': 'Fail',
'expect': 'in primary disk',
'actual': 'not in primary disk',
'note': 'none'
}
common_function.update_cases_result(report_file, case_name, step1)
if primary_result is not True:
return False
extended_result = check_storage.check_disk_extended()
if extended_result is True:
step2 = {
'step_name': 'Check whether disk is extended',
'result': 'Pass',
'expect': 'extended',
'actual': 'extended',
'note': 'none'
}
else:
step2 = {
'step_name': 'Check whether disk is extended',
'result': 'Fail',
'expect': 'extended',
'actual': 'not extended',
'note': 'none'
}
common_function.update_cases_result(report_file, case_name, step2)
def start(case_name, **kwargs):
SwitchThinProMode(switch_to='admin')
# report_file = network_function.system_ip() + '.yaml'
# ip = common_function.check_ip_yaml()
# report_file = get_root_path("Test_Report/{}.yaml".format(ip))
base_name = get_report_base_name()
report_file = get_current_dir('Test_Report', base_name)
common_function.new_cases_result(report_file, case_name) # new report
security_boot = SecurityBoot()
current_platform = common_function.get_platform()
if current_platform[0] == 't':
platform_type = 'DTC'
elif current_platform[0] == 'm':
platform_type = 'MTC'
else:
step1 = {
'step_name': 'Check platform type',
'result': 'Fail',
'expect': 'DTC or MTC',
'actual': 'invalid platform type',
'note': 'none'
}
common_function.update_cases_result(report_file, case_name, step1)
return
check_result = security_boot.check_security_boot(platform_type)
if check_result is True:
step2 = {
'step_name': 'Check whether security boot enabled or not',
'result': 'Pass',
'expect': 'Enable',
'actual': 'Disable',
'note': 'none'
}
elif check_result == 'skip checking':
step2 = {
'step_name':
'Check whether security boot enabled or not',
'result':
'Fail',
'expect':
'Skip checking security boot',
'actual':
'Skip checking security boot for platform {}'.format(
security_boot.target_platform),
'note':
'none'
}
else:
step2 = {
'step_name': 'Check whether security boot enabled or not',
'result': 'Fail',
'expect': 'Enable',
'actual': check_result,
'note': 'none'
}
common_function.update_cases_result(report_file, case_name, step2)
def website_test222(bypass_text, accessed_list, not_accessed_list,
case_name, report_file):
log.info('wait 10s')
time.sleep(10)
rs = False
steps = {
'step_name': "test no proxy: ".format(bypass_text),
'result': '',
'expect': 'status code should be 200',
'actual': '',
'note': ''
}
for j in accessed_list:
log.info("verify {} can be accessed".format(j))
log.info('get data from {}'.format(j))
try:
data = requests.get(j, timeout=5).status_code
except Exception:
data = 'Error'
log.info('status code is: {}'.format(data))
if data == 200:
s = 'Pass'
rs = True
else:
s = 'Fail'
rs = False
log.info('test {}'.format(s))
steps['result'] = s
common_function.update_cases_result(report_file, case_name, steps)
for i in not_accessed_list:
log.info("verify {} can not be accessed".format(i))
log.info('get data from {}'.format(i))
try:
data = requests.get(i, timeout=5).status_code
except Exception:
data = 'Error'
log.info('status code is: {}'.format(data))
steps = {
'step_name': "verify {} can not be accessed".format(i),
'result': '',
'expect': 'status code should be Error',
'actual': data,
'note': ''
}
if data == 'Error':
s = 'Pass'
rs = True
else:
s = 'Fail'
rs = False
log.info('test {}'.format(s))
steps['result'] = s
common_function.update_cases_result(report_file, case_name, steps)
return rs
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 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 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
pyautogui.moveTo(1, 1) # Move cursor in case it's at the corner of screen and PyAutuGui fail-safe is triggered
time.sleep(1)
saver = ScreenSave()
saver.switch_user('admin')
if not saver.open_screensaver_menu():
return False
scr_saver_check = ScreenSaverCheck()
ss = scr_saver_check.enable_SS_checked
if not ss:
enable_saver = saver.wait_pictures('2')
pyautogui.click(enable_saver[0], enable_saver[1])
pyautogui.press('tab', presses=2, interval=0.5)
else:
pyautogui.press('tab', presses=6, interval=0.5)
pyautogui.typewrite('1')
time.sleep(1)
enable_saver = saver.wait_pictures('2')
if enable_saver:
pyautogui.click(enable_saver[0], enable_saver[1])
else:
return False
saver.apply_and_save()
saver.close_window()
time.sleep(65)
pyautogui.click()
time.sleep(1)
unlock_dialog_folder = saver.path + '/Test_Data/td_power_manager/ScreenSaver/_lock_screen'
unlock_dialog = wait_element(unlock_dialog_folder)
if unlock_dialog:
step = {'step_name': 'Check whether screensaver is activated or not',
'result': 'Fail',
'expect': 'Screensaver should not be activated after 1 min.',
'actual': 'Screensaver is activated after 1 min.',
'note': 'none'}
pyautogui.typewrite('1')
time.sleep(1)
pyautogui.hotkey('enter')
time.sleep(1)
else:
step = {'step_name': 'Check whether screensaver is activated or not',
'result': 'Pass',
'expect': 'Screensaver should not be activated after 1 min.',
'actual': 'Screensaver is not activated after 1 min.',
'note': 'none'}
common_function.update_cases_result(report_file, case_name, step)
saver.restore_default_settings()
def set_no_proxy(self, fill_all_protocol, bypass_text, case_name,
report_file):
log.info('set bypass: {}'.format(bypass_text))
steps = {
'step_name': 'set {} {}'.format(self.protocol, bypass_text),
'result': 'Fail',
'expect': 'icon can be recognised',
'actual': '',
'note': ''
}
proxy_list = ['http', 'ftp', 'https']
t = self.dns.open_dns()
if not t:
log.info('Failed to recognise DNS icon')
steps['actual'] = 'Failed to recognise DNS icon'
common_function.update_cases_result(report_file, case_name, steps)
self.dns.close_dns()
return
if fill_all_protocol:
for i in proxy_list:
proxy_text = self.get_proxy_server('proxy3').replace(
self.protocol, 'http')
t2 = self.dns.set_value(i, proxy_text)
if not t2:
log.info('Failed to recognise {} icon'.format(i))
steps['actual'] = 'Failed to recognise {} icon'.format(i)
common_function.update_cases_result(
report_file, case_name, steps)
self.dns.close_dns()
return
t3 = self.dns.set_value(self.protocol, bypass_text)
time.sleep(5)
if not t3:
log.info('Failed to recognise noproxy icon')
steps['actual'] = 'Failed to recognise noproxy icon'
common_function.update_cases_result(report_file, case_name, steps)
self.dns.close_dns()
return
t4 = self.dns.close_dns()
if not t4:
log.info('Failed to recognise apply icon')
steps['actual'] = 'Failed to recognise apply icon'
common_function.update_cases_result(report_file, case_name, steps)
return
log.info('proxy set successfully')
steps['actual'] = 'proxy set successfully'
steps['result'] = 'Pass'
common_function.update_cases_result(report_file, case_name, steps)
return True
def update_case_result(result, step_name, **kwargs):
case_name = kwargs.get("case_name")
report_file = kwargs.get("report_file")
if result:
step = {'step_name': step_name,
'result': 'Pass',
'expect': '{} successfully.'.format(step_name),
'actual': '{} successfully.'.format(step_name),
'note': 'none'}
else:
step = {'step_name': step_name,
'result': 'Fail',
'expect': '{} successfully.'.format(step_name),
'actual': '{} failed.'.format(step_name),
'note': 'none'}
common_function.update_cases_result(report_file, case_name, step)
def step4(*args, **kwargs):
case_name = kwargs.get("case_name")
report_file = kwargs.get("report_file")
SwitchThinProMode(switch_to='user')
tl = TelnetLinux()
tl.logon()
lock_screen()
time.sleep(2)
pyautogui.press('enter')
time.sleep(1)
a = click_icon('locked_dialog')
if not a:
log.debug(
"first check not found locked dialog",
common_function.get_current_dir(
'Test_Report', 'img',
'{}_locked_dialog.png'.format(case_name.replace(' ', '_'))))
pyautogui.press('enter')
time.sleep(1)
a = click_icon('locked_dialog')
pyautogui.press('esc')
time.sleep(1)
b = click_icon('locked_dialog')
unlock_screen('root', '1')
tl.logoff()
log.info('press esc before {}, press esc after {}'.format(a, b))
if a and not b:
steps = {
'step_name': "verify press esc key will dismiss the dialog",
'result': 'Pass',
'expect': 'success',
'actual': 'success',
'note': ''
}
common_function.update_cases_result(report_file, case_name, steps)
else:
steps = {
'step_name': "verify press esc key will dismiss the dialog",
'result': 'Fail',
'expect': 'success',
'actual': 'fail',
'note': ''
}
common_function.update_cases_result(report_file, case_name, steps)
reset_settings()
return False
def userlock_is_1(**kwargs):
report_file = kwargs.get("report_file")
case_name = kwargs.get("case_name")
hostname = get_default_hostname()
log.info("{:-^80}".format("start a case test"))
log.info("case name:" + case_name)
cf.SwitchThinProMode("admin")
modify_hostname_registry("asdfgh")
wired = network_setting.Wired()
wired_connection_mode = subprocess.getoutput(
"mclient --quiet get root/Network/Wired/Method")
if wired_connection_mode is not "Automatic":
subprocess.call(
"mclient --quiet set root/Network/Wired/Method 'Automatic'",
shell=True)
subprocess.call("mclient commit", shell=True)
for i in range(20):
log.info("wait connect network...")
time.sleep(2)
if wired.check_wired_is_connected():
log.info("wired is connected")
break
set_userlock("1")
export_profile()
if not set_static_network():
log.error("set static network error")
report = {
'step_name': 'set static network',
'result': 'fail',
'expect': "set static network success",
'actual': "set static network fail",
'note': ''
}
cf.update_cases_result(report_file, case_name, report)
teardown_test_environment()
modify_hostname_registry(hostname)
cf.import_profile()
os.remove(cf.get_current_dir("Test_Data/profile_file.xml"))
log.error("{:+^80}".format("test case fail"))
return False
import_profile()
log.info("reboot")
time.sleep(30)
