def setUp(cls):
"""启动应用"""
cls.result = unittest.TestResult()
cls.base_assert = ExpectingTest(cls, cls.result)
cls.login = LoginPage()
cls.home = HomePage()
cls.detail = VanclassDetailPage()
cls.van = VanclassPage()
cls.homework = Homework()
cls.game = SingleChoice()
BasePage().set_assert(cls.base_assert)
def setUp(cls):
"""启动应用"""
cls.result = unittest.TestResult()
cls.base_assert = ExpectingTest(cls, cls.result)
cls.login_page = LoginPage()
cls.home = HomePage()
cls.user_center = UserCenterPage()
cls.user_info = UserInfoPage()
cls.change_image = ChangeImage()
cls.screen_shot = ScreenShot()
BasePage().set_assert(cls.base_assert)
def setUp(cls):
"""启动应用"""
cls.result = unittest.TestResult()
cls.base_assert = ExpectingTest(cls, cls.result)
cls.home = HomePage()
cls.login = LoginPage()
cls.exam = ExamPage()
cls.detail = DetailPage()
cls.login.app_status() # 判断APP当前状态
cls.common = DataPage()
BasePage().set_assert(cls.base_assert)
def setUp(cls):
"""启动应用"""
cls.result = unittest.TestResult()
cls.base_assert = ExpectingTest(cls, cls.result)
cls.login_page = LoginPage()
cls.home = HomePage()
cls.user_center = UserCenterPage()
cls.user_info = UserInfoPage()
cls.pwd = PwdReset()
BasePage().set_assert(cls.base_assert)
cls.login_page.app_status()
def setUp(cls):
"""启动应用"""
cls.result = unittest.TestResult()
cls.base_assert = ExpectingTest(cls, cls.result)
cls.home = HomePage()
cls.login = LoginPage()
cls.word_rebuild = WordBookRebuildPage()
cls.login.app_status() # 判断APP当前状态
BasePage().set_assert(cls.base_assert)
cls.word_info = {} # 记录所有单词
cls.new_explain_words = []
def setUp(cls):
"""启动应用"""
cls.result = unittest.TestResult()
cls.base_assert = ExpectingTest(cls, cls.result)
cls.login = LoginPage()
cls.home = HomePage()
cls.user_center = UserCenterPage()
cls.setting = Setting()
cls.protocol = ProtocolPage()
BasePage().set_assert(cls.base_assert)
cls.login.app_status()
def setUp(cls):
"""启动应用"""
cls.result = unittest.TestResult()
cls.base_assert = ExpectingTest(cls, cls.result)
cls.home = HomePage()
cls.login_page = LoginPage()
cls.login = LoginPage()
cls.medal = MedalPage()
cls.library = LibraryPage()
BasePage().set_assert(cls.base_assert)
cls.login.app_status()
def setUp(cls):
"""启动应用"""
cls.result = unittest.TestResult()
cls.base_assert = ExpectingTest(cls, cls.result)
cls.home = HomePage()
cls.login = LoginPage()
cls.word_test = WordTestPage()
cls.word_result = WordTestResultPage()
cls.word_rebuild = WordBookRebuildPage()
cls.login.app_status() # 判断APP当前状态
BasePage().set_assert(cls.base_assert)
def get_user_info(self):
""":return 学生id、学校名称、学校id、昵称"""
HomePage().click_tab_profile() # 点击个人中心
if self.wait_check_user_center_page(): # 个人中心页面检查点
self.screen_swipe_up(0.5, 0.2, 0.8, 1000)
nickname = self.nickname() # 昵称
self.screen_swipe_up(0.5, 0.8, 0.2, 1000)
self.purchase().click() # 点击购买
if self.wait_check_buy_page(): # 购买页面检查点
phone = self.phone() # 手机号
stu_id = WordBookSql().find_student_id(phone) # 根据手机号获取学生ID
self.click_back_up_button()
if self.wait_check_user_center_page():
school_name = self.school_name() # 学习名称
school_id = 0
if school_name:
id1 = LibrarySql().find_school_id(school_name)
id2 = LibrarySql().find_school_id_by_short_name(
school_name)
if id1:
school_id = id1[0][0]
else:
school_id = id2[0][0]
self.setting_up().click()
if self.wait_check_logout_page(): # 清除缓存
self.clear_cache().click()
time.sleep(2)
self.click_back_up_button() # 返回个人中心
if self.wait_check_user_center_page():
HomePage().click_tab_hw() # 点击学习返回主页面
print('学生昵称：', nickname, '\n', '学校名称：', school_name, '\n',
'学校id：', school_id, '\n', '学生id：', stu_id[0][0],
'\n')
return stu_id[0][0], school_name, school_id, nickname
class DataHandlePage(BasePage):
mysql = LibrarySql()
user = UserCenterPage()
home = HomePage()
@teststep
def get_library_label_id(self, school_id, label_name):
"""获取图书馆标签id"""
result = self.mysql.find_library_label_id_by_name(
school_id, label_name)
return result[0][0] if result else -1
@teststep
def get_label_book_list(self, school_id, label_id):
"""根据标签id获取图书id"""
result = self.mysql.find_label_book_set_list(school_id, label_id)
return {x[0]: (x[1], x[2]) for x in result}
@teststep
def get_book_book_set_list(self, book_id):
"""获取书籍下所有书单名称"""
result = self.mysql.find_book_name_by_id(book_id)
return [x[0] for x in result]
@teststep
def get_book_id_by_name_and_desc(self, school_id, book_name, description):
"""根据图书名称和图书简介获取图书id"""
result = self.mysql.find_book_id_by_name_and_desc(
school_id, book_name, description)
return result[0][0]
def student_today_is_submit_bank_record(self, stu_id, book_name,
book_description):
"""查询此书籍的书单该学生今日是否已经学习过"""
book_set_ids = self.mysql.find_book_set_ids(book_name,
book_description)
if book_set_ids:
reform_book_set_ids = str(book_set_ids[0][0].split(','))[1:-1]
print('书籍下书单id：', reform_book_set_ids)
book_record = self.mysql.find_student_book_today_study_record(
stu_id, reform_book_set_ids)
print('三本书今日是否学习过：', book_record)
if len(book_record):
return True
else:
return False
else:
return False
def tips_goto_pay_operate(self):
"""去购买"""
if self.wait_check_buy_page(10):
if self.img_judge(): # 判断图片 是否存在
print('------------------------------')
print('购买提示页：')
self.tips_title()
self.tips_content()
self.goto_pay_button() # 去购买 按钮
self.buy_page_direct_operate()
HomePage().click_back_up_button() # 返回 购买提示页
if self.wait_check_buy_page(10):
self.goto_verification().click() # 已有【提分版】， 去验证
Toast().find_toast('已更新账户信息')
def check_study_model_operate(self, study_model=1):
"""查看单词本学习设置操作"""
HomePage().click_tab_profile()
if self.wait_check_user_center_page():
self.screen_swipe_up(0.5, 0.8, 0.2, 1000)
self.study_setting()[0].click()
if self.wait_check_study_setting_page():
self.study_setting()[0].click()
if self.wait_check_wordbook_study_setting_page():
thirty_model = self.get_study_setting_side()[0]
if thirty_model.get_attribute('clickable') == 'false':
print('❌❌❌ 默认单词本学习设置不为每组30词')
if study_model == 2:
self.study_setting()[1].click()
self.study_setting()[0].click()
if Toast().find_toast('一天内规则不可重复设置'):
print('规则一天内不可重复设置')
else:
print('❌❌❌ 未发现不可重复设置提示')
self.click_back_up_button()
if self.wait_check_study_setting_page():
self.click_back_up_button()
if self.wait_check_user_center_page():
HomePage().click_tab_hw()
def test_listen_game(self, level_name):
if self.game.home.wait_check_home_page(): # 页面检查点
user_data = UserCenterPage().get_user_info()
stu_id = user_data[0]
ListenDataHandle().delete_student_all_listening_records(stu_id)
if self.game.home.wait_check_home_page(): # 页面检查点
print('进入主界面', '\n')
self.game.home.click_hk_tab(4) # 点击每日一听
if self.listen.wait_check_listen_everyday_home_page():
self.listen.level_button().click()
if self.level.wait_check_listening_level_page():
while not self.level.wait_check_level_page(level_name):
HomePage().screen_swipe_up(0.5, 0.8, 0.4, 1000)
if self.level.start_button(level_name).text == '开始':
self.level.start_button(level_name).click()
self.game.home.click_back_up_button()
level_num = int(re.findall(r'\d+', level_name)[0])
print('练习等级：', level_num)
exercise_count = 3 if level_num > 4 else 5
print('练习次数：', exercise_count)
for i in range(exercise_count + 1):
if self.listen.wait_check_listen_everyday_home_page():
self.listen.start_button().click()
if self.game.wait_check_gaming_page():
bank_type, bank_info = self.game.play_listen_game_process()
self.game.answer_page_operate(bank_type, bank_info)
if self.game.wait_check_result_page():
self.game.click_back_up_button()
elif self.listen.wait_check_degrade_page():
print('是否感觉题太难了，需要切换到稍简单级别的练习吗？', '\n')
self.game.home.commit()
elif self.listen.wait_check_certificate_page():
print('该等级已学习完毕（没有题目）')
GameCommonEle().share_page_operate()
if self.listen.wait_check_certificate_page():
self.listen.start_excise_button().click()
if i == exercise_count:
if self.listen.wait_today_limit_img_page():
print('今天你已练完{}道听力，保持适度才能事半公倍哦！'.format(exercise_count), '\n')
self.listen.commit_button().click()
else:
self.base_assert.except_error(' Error-- 未发现题数限制提示页面！')
def play_bank_cloze_game(self, num, exam_json):
"""选词填空 答卷过程 """
exam_json['选词填空'] = bank_json = {}
article = self.rich_text() # 获取文章
print(article.text)
if self.wait_check_hint_btn_page():
self.hint_btn().click() # 点击提示词，检验提示页面是否出现
if not self.wait_check_hint_content_page():
self.base_assert.except_error('点击提示词按钮未出现提示词')
else:
print('提示词：', self.hint_answer())
HomePage().click_blank()
for i in range(num): # 其他点击回车键顺序填空，填空的文本为26个字母随机填写3-6个
input_answer = self.select_blank_play_process()
print('我输入的：', input_answer)
bank_json[i] = input_answer
AnswerPage().skip_operator(i, num, '选词填空', self.wait_check_select_blank_page,
self.judge_tip_status, input_answer.lower())
def select_blank_lib_hw_operate(self, fq, half_exit, sec_answer=None):
"""选词填空操作"""
mine_answer = {}
timer = []
if self.wait_check_hint_btn_page():
self.hint_btn().click() # 点击提示词，检验提示页面是否出现
if not self.wait_check_hint_content_page():
self.base_assert.except_error('点击提示词按钮未出现提示词')
else:
print('提示词：', self.hint_answer())
HomePage().click_blank()
if fq == 1:
content = self.rich_text()
print(content.text)
total_count = self.rest_bank_num()
for x in range(total_count):
self.rate_judge(total_count, x)
self.next_btn_judge('false', self.fab_commit_btn) # 判断下一步状态
if half_exit:
if x == 1:
self.click_back_up_button()
self.tips_operate()
break
if fq == 1:
input_answer = self.select_blank_play_process()
else:
right_answer = sec_answer[str(x)]
input_answer = self.select_blank_play_process(
do_right=True, right_answer=right_answer)
mine_answer[str(x)] = input_answer
timer.append(self.bank_time())
if not half_exit:
self.judge_timer(timer)
print('本次做题答案：', mine_answer)
self.check_position_change()
self.next_btn_operate('true', self.fab_commit_btn) # 判断下一步状态
return mine_answer
def setUp(cls):
cls.home = HomePage()
cls.word = WordBook()
cls.mine = MyWordPage()
cls.common = WordBookDataHandle()
class ExamPage(BasePage):
"""试卷页面"""
home = HomePage()
answer = AnswerPage()
wait = WaitElement()
@teststep
def wait_check_exam_title_page(self):
"""以 试卷的标题作为 页面检查点"""
locator = (By.XPATH, "//android.widget.TextView[contains(@text,'试卷')]")
return self.wait.wait_check_element(locator)
@teststep
def wait_check_exam_counter_page(self):
"""以 做试卷时的计时作为 页面检查点"""
locator = (By.ID, self.id_type() + "time_container")
return self.wait.wait_check_element(locator)
@teststep
def wait_check_exam_confirm_page(self):
"""以 试卷确认的标题作为 页面检查点"""
locator = (By.XPATH,
"//android.widget.TextView[contains(@text,'试卷确认')]")
return self.wait.wait_check_element(locator)
@teststep
def wait_check_rank_page(self):
"""以 炫耀一下的text作为 页面检查点"""
locator = (By.XPATH,
"//android.widget.TextView[contains(@text,'炫耀一下')]")
return self.wait.wait_check_element(locator)
@teststep
def wait_check_end_page(self):
"""等待 滑到底提示"""
locator = (By.XPATH,
'//android.widget.TextView[contains(@text,"到底啦 下拉刷新试试")]')
return self.wait.wait_check_element(locator, timeout=5)
@teststep
def exam_names(self):
"""试卷名称"""
locator = (By.ID, self.id_type() + 'tv_name')
return self.wait.wait_find_elements(locator)
@teststep
def finish_count(self):
"""完成人数"""
locator = (By.ID, self.id_type() + 'tv_finishcount')
return self.wait.wait_find_elements(locator)
@teststep
def finish_status(self):
"""完成状态"""
locator = (By.ID, self.id_type() + 'rtv_mode')
return self.wait.wait_find_elements(locator)
@teststep
def get_all_text(self):
"""获取所有文本"""
locator = (By.CLASS_NAME, 'android.widget.TextView')
return self.wait.wait_find_elements(locator)
@teststep
def click_start_exam_button(self):
"""点击 开始考试"""
locator = (By.ID, self.id_type() + 'start_write')
self.wait.wait_find_element(locator).click()
@teststep
def index_group(self):
locator = (By.ID, self.id_type() + 'recyclerview')
return self.wait.wait_find_elements(locator)
@teststep
def close_answer(self):
"""关闭答题卷页面"""
locator = (By.ID, self.id_type() + 'answerclose')
self.wait.wait_find_element(locator).click()
@teststep
def exam_back_to_home(self):
self.home.click_back_up_button()
if self.wait_check_exam_title_page():
self.home.click_back_up_button()
if self.home.wait_check_home_page():
print('返回主页面')
@teststeps
def select_one_exam(self):
"""随机选择一个试卷"""
exams_info = {} # 将试卷存入一个字典当周，以试卷名作为key，试卷描述与完成状态作为value
while True:
exams = self.exam_names()
finish_status = self.finish_status() # 试卷完成状态
finish_count = self.finish_count() # 试卷几人完成
for i in range(len(exams)):
exams_info[exams[i].text] = finish_status[
i].text + ' -- ' + finish_count[i].text
if not self.wait_check_end_page(): # 没有发现滑动到底的则进行滑动
self.home.screen_swipe_up(0.5, 0.9, 0.7, 1000)
else:
# exams_info[exams[-1].text] = finish_status[-1].text + ' -- ' + finish_count[-1].text
self.home.screen_swipe_down(0.5, 0.2, 0.9, 1000)
break
for name in exams_info.keys():
print(name, ' ', exams_info[name])
exam = self.exam_names()[0]
test_name = exam.text
print('选择试卷：', test_name)
exam.click()
print('------------------------------\n')
return test_name
@teststeps
def exam_confirm_ele_operate(self):
"""确认页面 文本展示"""
ele = self.get_all_text()
print('\n<试卷确认页面>：\n')
self.print_exam_info(ele)
print(ele[14].text + '\n' + ele[15].text + '\n' + ele[16].text + '\n' +
ele[17].text) # 说明
print('--------------------------------\n')
return int(ele[9].text)
@teststep
def print_exam_info(self, ele):
"""打印出试卷头部信息"""
print(ele[1].text, ':', ele[2].text) # 试卷名称
print(ele[5].text, ':', ele[3].text + ele[4].text) # 试卷模式
print(ele[8].text, ':', ele[6].text + ele[7].text) # 时间
print(ele[11].text, ':', ele[9].text + ele[10].text) # 题数
print(ele[13].text, ':', ele[12].text) # 限制
@teststeps
def get_ques_name(self, total):
"""获取所有题型"""
if self.wait_check_exam_counter_page():
self.answer.answer_check_button().click()
if self.answer.wait_check_answers_page():
tip_num = []
tips = []
while True:
titles = self.answer.question_titles()
for i, x in enumerate(titles):
if x.text in tips:
continue
else:
if i == len(titles) - 1:
self.home.screen_swipe_up(0.5, 0.87, 0.7, 1000)
ques_num = self.answer.ques_num(x.text)
num = int(re.findall(r'\d+', ques_num)[0])
tips.append(x.text)
print(x.text, ' ', ques_num)
tip_num.append(num)
if sum(tip_num) < total:
self.home.screen_swipe_up(0.5, 0.9, 0.4, 1000)
else:
break
self.close_answer()
print('--------------------------------\n')
return tips
@teststeps
def play_examination(self, tips, exam_json):
"""做题过程"""
if self.wait_check_exam_counter_page():
self.answer.answer_check_button().click() # 查看答题卷
if self.answer.wait_check_answers_page():
index = 0
while index < len(tips):
title_list = [
x.text for x in self.answer.question_titles()
] # 题型数组
print(title_list)
if tips[index] in title_list:
first_index = self.answer.tip_index(
tips[index]) # 题型的第一道题
ques_num = self.answer.ques_num(
tips[index]) # 题数描述 （共*题）
num = int(''.join(re.findall(r'\d+',
ques_num))) # 从描述中获取题数
first_index[0].click() # 点击第一题进入习题
self.exam_process(tips[index], num,
exam_json) # 对应习题的游戏过程
self.answer.answer_check_button().click(
) # 游戏结束后点击答题卷进入下一题
if self.answer.wait_check_answers_page():
pass
index = index + 1
else:
self.home.screen_swipe_up(0.5, 0.8, 0.4, 2000)
if self.answer.wait_check_answers_page():
self.answer.submit_tip_operate() # 交卷
if self.wait_check_rank_page():
self.exam_back_to_home() # 返回
@teststeps
def exam_process(self, title, num, exam_json):
print('\n-------%s-共%d题------\n' % (title, num))
if '听后选择' in title:
ListenSelect().play_listening_select_game(num, exam_json)
self.answer.wait_result_btn_enabled()
elif '猜词游戏' in title:
GuessingWord().play_guessing_word_game(num, exam_json)
elif '单项选择' in title:
SingleChoice().play_single_choice_game(num, exam_json)
elif '词汇选择' in title:
VocabSelect().play_vocab_select_game(num, exam_json)
elif '单词拼写' in title:
WordSpell().play_word_spell_game(num, exam_json)
elif '单词听写' in title:
ListenSpell().play_listen_spell_game(num, exam_json)
elif '连词成句' in title:
Conjunctions().play_conjunctions_game(num, exam_json)
elif '还原单词' in title:
RestoreWord().play_restore_word_game(num, exam_json)
elif '连连看' in title:
WordMatch().play_word_match_game(num, exam_json)
elif '强化炼句' in title:
SentenceEnhance().play_sentence_enhance_game(num, exam_json)
elif '听音连句' in title:
ListenSentence().play_listen_sentence_game(num, exam_json)
elif '句型转换' in title:
ExamSentenceExchange().play_sentence_exchange_game(num, exam_json)
elif '完形填空' in title:
ClozeTest().play_cloze_test_game(num, exam_json)
elif '选词填空' in title:
BlankCloze().play_bank_cloze_game(num, exam_json)
elif '补全文章' in title:
CompleteText().play_complete_article_game(num, exam_json)
elif '阅读理解' in title:
ReadUnderstand().play_read_understand_game(num, exam_json)
else:
pass
def __init__(self):
self.home = HomePage()
self.van = VanclassPage()
self.wait = WaitElement()
def setUp(cls):
"""启动应用"""
cls.login_page = LoginPage()
cls.home_page = HomePage()
cls.homework = Homework()
cls.guess_word = GuessWord()
def __init__(self):
self.mysql = WordBookSql()
self.home = HomePage()
self.user_info = UserInfoPage()
class QuitAddClass(BasePage):
def __init__(self):
self.home = HomePage()
self.van = VanclassPage()
self.wait = WaitElement()
@teststep
def wait_check_vanclass_page(self):
"""班级页面检查点"""
locator = (By.CLASS_NAME, self.id_type() + "class_name")
return self.wait.wait_check_element(locator)
@teststep
def class_num(self):
"""班号"""
locator = (By.ID, self.id_type() + 'class_no')
return self.wait.wait_find_elements(locator)
@teststep
def quit_all_class_operate(self):
"""退出班级操作"""
self.home.click_test_vanclass() # 班级tab
if self.van.wait_check_page(): # 班级页面检查点
self.home.screen_swipe_down(0.5, 0.2, 0.9, 1000)
while self.wait_check_vanclass_page():
if self.van.wait_check_page():
van_name = self.van.class_name()[0].text
self.van.class_name()[0].click()
self.quit_tips_operate(van_name) # 退出班级提示框
@teststep
def quit_tips_operate(self, van_name):
"""退出班级 具体操作"""
if self.van.wait_check_vanclass_page(van_name): # 页面检查点
self.van.quit_vanclass() # 退出班级 按钮
self.home.tips_operate_commit() # 提示框
print('确定 退出')
print('------------------------------')
if self.van.wait_check_quit_page():
self.van.phone_name() # 提示
value = verify_find(STU_ACCOUNT, 'quitClass') # 获取验证码
self.van.code_input().send_keys(value) # 输入验证码
print(STU_ACCOUNT)
print('验证码:', value)
self.van.quit_button() # 退出班级 按钮
@teststep
def apply_class_operate(self, test_class_num):
"""加入班级操作"""
self.home.click_test_vanclass() # 班级tab
if self.van.wait_check_page(): # 班级页面检查点
if self.van.wait_check_van_list_page():
class_nums = self.class_num()
van_names = []
while len(van_names) < len(class_nums): # 非测试班级则退出，是则保留
for i, num in enumerate(self.class_num()):
class_name = self.van.class_name()[i].text
van_num = num.text.split('：')[1]
if class_name in van_names:
continue
else:
van_names.append(class_name)
if van_num not in test_class_num: # 检验是否已加入测试班级
num.click() # 不是测试班级的
self.quit_tips_operate(class_name) # 退出班级
else:
test_class_num.remove(van_num)
if len(test_class_num):
for x in test_class_num:
if self.van.wait_check_page():
self.van.add_class_button() # 若没有班级列表
if self.home.wait_check_tips_page(): # 页面检查点
self.home.input().send_keys(x) # 输入班级号
self.home.commit_button() # 点击确定按钮
if self.van.wait_check_apply_page():
print('班级：', self.van.class_name_modify())
print('班号：', self.van.apply_vanclass_no())
print('老师：', self.van.apply_teacher_name())
self.van.remark_name_modify().send_keys('Test') # 输入昵称
self.van.apply_class_button() # 申请入班 按钮
print('-'*30, '\n')
self.home.click_tab_hw()
def online_services_operate(self):
"""在线客服"""
self.online_service() # 点击在线客服
if self.wait_check_help_page():
HomePage().click_back_up_button()
def setUp(cls):
"""启动应用"""
cls.login_page = LoginPage()
cls.home_page = HomePage()
cls.homework = Homework()
cls.word_spelling = WordSpelling()
def __init__(self):
self.home = HomePage()
self.wait = WaitElement()
def setUp(cls):
"""启动应用"""
cls.login_page = LoginPage()
cls.home_page = HomePage()
cls.homework = Homework()
cls.vocab_select = VocabularyChoice()
class RankingPage(BasePage):
"""单词本 - 排行榜"""
def __init__(self):
self.home = HomePage()
self.wait = WaitElement()
@teststeps
def wait_check_rank_page(self):
"""以“学生测试版”为依据"""
locator = (By.XPATH,
"//android.widget.TextView[contains(@text,'学生测试版')]")
return self.wait.wait_check_element(locator)
@teststep
def total(self):
locator = (By.ID, self.id_type() + 'total')
ele = self.wait.wait_find_element(locator)
return ele.text
@teststep
def click_rank_icon(self):
"""点击排行榜图标"""
locator = (By.ID, self.id_type() + 'rank')
self.wait.wait_find_element(locator).click()
@teststep
def choose_class(self):
"""班级展示 及切换"""
locator = (By.ID, "android:id/text1")
self.wait.wait_find_element(locator).click()
time.sleep(2)
@teststep
def classes_ele(self):
"""班级展示 及切换"""
locator = (By.ID, "android:id/text1")
return self.wait.wait_find_elements(locator)
@teststep
def word_num(self):
"""单词数"""
locator = (By.ID, self.id_type() + "tv_score")
ele = self.wait.wait_find_element(locator)
return ele.text
@teststep
def word_type(self):
"""wording:词"""
locator = (By.ID, self.id_type() + "type")
ele = self.wait.wait_find_element(locator)
return ele.text
@teststep
def share_button(self):
"""炫耀一下"""
locator = (By.ID, self.id_type() + "share")
self.wait.wait_find_element(locator).click()
@teststep
def rank_num(self):
"""班级排名"""
locator = (By.ID, self.id_type() + "tv_ranking")
ele = self.wait.wait_find_element(locator)
return ele.text
@teststep
def order_num(self):
"""排名 数字"""
locator = (By.ID, self.id_type() + "tv_order")
return self.wait.wait_find_elements(locator)
@teststep
def st_icon(self):
"""头像"""
locator = (By.ID, self.id_type() + "iv_head")
return self.wait.wait_find_elements(locator)
@teststep
def st_name(self):
"""学生姓名"""
locator = (By.ID, self.id_type() + "tv_name")
return self.wait.wait_find_elements(locator)
@teststep
def st_score(self):
"""提示title"""
locator = (By.ID, self.id_type() + "tv_score")
return self.wait.wait_find_elements(locator)
@teststep
def students_name(self):
"""排行榜里学生名称"""
locator = (By.XPATH,
'//android.widget.RelativeLayout/android.widget.TextView'
'[contains(@resource-id, "{}tv_name")]'.format(
self.id_type()))
return self.wait.wait_find_elements(locator)
@teststep
def students_score(self):
"""排行榜中学生背的单词数"""
locator = (By.XPATH,
'//android.widget.RelativeLayout/android.widget.TextView'
'[contains(@resource-id,"{}tv_score")]'.format(
self.id_type()))
return self.wait.wait_find_elements(locator)
# 炫耀一下
@teststeps
def wait_check_share_page(self):
"""以“title: 炫耀一下”为依据"""
locator = (By.XPATH,
"//android.widget.TextView[contains(@text,'炫耀一下')]")
return self.wait.wait_check_element(locator)
@teststep
def play_rank_word(self, total_word):
print('排行榜 页面\n')
self.choose_class()
time.sleep(2)
classes = self.classes_ele()
for i in range(len(classes)):
stu_class = self.classes_ele()[i].text
self.classes_ele()[i].click()
time.sleep(3)
self.ele_operate(stu_class, total_word)
if i != len(classes) - 1:
self.choose_class()
else:
print('排行榜浏览结束')
WordBookRebuildPage().click_back_up_button()
@teststep
def ele_operate(self, stu_class, total_word):
word_type = self.word_type()
class_rank = self.rank_num()
print('当前所在班级：', stu_class)
score = self.st_score()[0].text
print('已背：', score + word_type)
if int(score) != int(total_word):
print('❌❌❌ Error - 次数与主页面单词数不一致！')
else:
print('单词数核实一致！')
print('当前班级排名：', class_rank)
self.share_button()
if self.wait_check_share_page():
self.home.click_back_up_button()
if self.wait_check_rank_page():
self.rank_numbers_info()
def get_student_rank_info(self, students_info, i):
student_names = self.students_name()
student_scores = self.students_score()
order = self.order_num()
for j in range(len(student_names)):
if i == 0:
if j <= 2:
if order[i].text != '':
print('❌❌❌ Error - 名次位于第三名没有小皇冠标识')
if student_names[j].text in students_info.keys():
continue
else:
students_info[student_names[j].text] = student_scores[j].text
return students_info
@teststep
def rank_numbers_info(self):
students_info = {}
student_names = self.students_name()
if len(student_names) >= 6:
for i in range(2):
students_info = self.get_student_rank_info(students_info, i)
self.home.screen_swipe_up(0.5, 0.8, 0.3, 1000)
else:
self.get_student_rank_info(students_info, i=0)
self.home.screen_swipe_down(0.5, 0.2, 0.9, 1000)
print("\n排行榜情况如下(只显示班级前10名 + 自己的名次)")
for name in students_info.keys():
score = students_info[name]
print(name, '\t', score)
time.sleep(3)
print('----------------------------------')
class ResultPage(BasePage):
def __init__(self):
self.home = HomePage()
self.wait = WaitElement()
@teststep
def wait_check_result_page(self):
"""结果页 以今日已练单词图片的Id为依据"""
locator = (By.ID, self.id_type() + 'word_count')
return self.wait.wait_check_element(locator)
@teststep
def wait_check_wx_login_page(self):
"""微信登陆页面检查点"""
locator = (By.XPATH,
'//android.widget.TextView[contains(@text,"登录微信")]')
return self.wait.wait_check_element(locator)
@teststep
def wait_check_share_page(self):
"""打卡页，以分享图片id为依据"""
locator = (By.ID, self.id_type() + "share_img")
return self.wait.wait_check_element(locator)
@teststep
def wait_check_next_grade(self):
"""再来一组 以继续挑战的图片的Id为依据"""
locator = (By.ID, self.id_type() + "level_up_hint")
return self.wait.wait_check_element(locator)
@teststep
def wait_check_study_times_limit_page(self):
"""练习次数已用完页面检查点"""
locator = (By.ID, self.id_type() + "error_img")
return self.wait.wait_check_element(locator)
@teststep
def date(self):
"""时间日期"""
locator = (By.ID, self.id_type() + 'date')
return self.wait.wait_find_element(locator).text
@teststep
def today_word(self):
"""今日已练单词"""
locator = (By.ID, self.id_type() + 'word_count')
return self.wait.wait_find_element(locator).text
@teststep
def already_remember_word(self):
"""已被单词"""
locator = (By.ID, self.id_type() + 'all_word_count')
return self.wait.wait_find_element(locator).text
@teststep
def word_detail_info(self):
"""复习新词组"""
locator = (By.ID, self.id_type() + 'text')
return self.wait.wait_find_element(locator).text
@teststep
def share_button(self):
"""打卡"""
locator = (By.ID, self.id_type() + 'punch_clock')
self.wait.wait_find_element(locator).click()
time.sleep(2)
@teststep
def rank_button(self):
"""右上角排名按钮"""
locator = (By.ID, self.id_type() + 'rank')
self.wait.wait_find_element(locator).click()
time.sleep(3)
@teststep
def more_again_button(self):
"""再来一组"""
print('再来一组', '\n')
locator = (By.ID, self.id_type() + 'again')
self.wait.wait_find_element(locator).click()
@teststep
def level_up_text(self):
"""单词已练完说明"""
locator = (By.ID, self.id_type() + 'level_up_hint')
ele = self.wait.wait_find_element(locator)
print(ele.text)
@teststep
def no_study_btn(self):
"""不练了"""
locator = (By.ID, self.id_type() + 'cancel')
self.wait.wait_find_element(locator).click()
@teststep
def wx_btn(self):
"""微信按钮"""
locator = (By.ID, self.id_type() + 'weixin')
return self.wait.wait_find_element(locator)
@teststep
def wx_friend(self):
"""朋友圈"""
locator = (By.ID, self.id_type() + 'weixin_friends')
return self.wait.wait_find_element(locator)
@teststep
def nex_level_text(self):
locator = (By.XPATH, "//android.widget.TextView[@index,0]")
ele = self.wait.wait_find_element(locator)
print('已选年级 :%s' % ele.text)
print('-' * 30, '\n')
@teststep
def confirm_button(self):
"""继续练习"""
locator = (By.ID, self.id_type() + "confirm")
self.wait.wait_find_element(locator).click()
@teststep
def wx_back_up_btn(self):
"""微信页面返回按钮"""
locator = (By.ACCESSIBILITY_ID, '返回')
return self.wait.wait_find_element(locator)
@teststep
def share_page_operate(self):
"""分享页面操作"""
if self.wait_check_share_page():
self.wx_btn().click()
if self.wait_check_wx_login_page():
self.wx_back_up_btn().click()
else:
print('❌❌❌ 未进入微信登陆页面')
if self.wait_check_share_page():
self.wx_friend().click()
if self.wait_check_wx_login_page():
self.wx_back_up_btn().click()
else:
print('❌❌❌ 未进入微信登陆页面')
if self.wait_check_share_page():
self.save_img().click()
if not Toast().find_toast('已保存到本地'):
print('❌❌❌ 未发现保存图片提示')
self.click_back_up_button()
@teststeps
def check_result_word_data(self, new_word_count, new_explain_words_count,
already_recite_count, group_count):
"""结果页面"""
print(' <结果页>：')
print('今日已练单词：%s' % self.today_word())
print('日期：%s' % self.date())
print(self.already_remember_word())
print(self.word_detail_info())
today_word_count = int(self.today_word()) # 今日已练单词 （复习+ 新词）
already_count = int(
re.findall(r'\d+', self.already_remember_word())[0]) # 已背单词
detail = re.findall(r'\d+', self.word_detail_info()) # 最后一句统计文本
study_group_count = int(detail[0]) # 已练组数
recite_count = int(detail[1]) # 复习个数
new_set_words = int(detail[2]) # 新词个数
new_explain_count = int(detail[3]) # 新释义个数
if already_count != new_word_count:
print('❌❌❌ 已学单词数不正确，应为', new_word_count)
if today_word_count != recite_count + new_set_words + new_explain_count:
print('❌❌❌ 今日已练单词不等于复习+新词+新释义, 应为',
recite_count + new_set_words + new_explain_count)
if study_group_count != group_count + 1:
print('❌❌❌ 已练组数不正确， 应为', group_count + 1)
if new_set_words != new_word_count:
print('❌❌❌ 新词学单词数不正确，应为', new_word_count)
if new_explain_count != new_explain_words_count:
print('❌❌❌ 新释义单词个数不正确， 应为', new_explain_words_count)
if recite_count != already_recite_count:
print('❌❌❌ 复习单词个数不正确， 应为', already_recite_count)
if recite_count > 27:
if group_count == 0:
if new_word_count != 0:
print('❌❌❌ 复习个数大于等于28个, 不应存在新词个数')
else:
print('❌❌❌ 复习组数非第一组, 但是复习个数大于27')
else:
if new_word_count == 0:
print('❌❌❌ 复习单词个数小于28, 新词个数为0')
else:
if group_count == 0:
if new_word_count not in range(3, 11):
print('❌❌❌ 复习单词个数小于28， 第一组新词个数不在3-10之间')
else:
if new_word_count < 3:
print('❌❌❌ 复习单词个数小于28，非第一组新词个数小于3个')
@teststep
def back_to_home(self):
self.home.click_back_up_button()
if self.home.wait_check_tips_page():
self.home.commit_button()
if self.home.wait_check_word_title():
self.home.click_back_up_button()
if self.home.wait_check_home_page(): # 页面检查点
print('返回主界面')
@teststeps
def result_page_handle(self,
new_word_count,
new_explain_words_count,
already_recite_count,
group_count,
study_model=1):
"""结果页处理"""
if self.wait_check_result_page():
print('进入结果页面')
self.check_result_word_data(new_word_count,
new_explain_words_count,
already_recite_count,
group_count) # 结果页元素
self.share_button() # 打卡
group_num = 6 if study_model == 1 else 9
GameCommonEle().share_page_operate() # 炫耀一下页面
if self.wait_check_result_page():
self.more_again_button() # 再练一次
if group_count == group_num:
if not self.wait_check_study_times_limit_page():
self.base_assert.except_error('练习次数已达到顶峰值， 未显示练完提示页面')
else:
print('你已练完今日单词， 保持适度才能事半功倍哦！休息一下，明天再练吧')
if self.wait_check_next_grade(): # 继续挑战页面
self.level_up_text()
self.confirm_button().click()
def __init__(self):
self.home = HomePage()
self.user_center = UserCenterPage()
self.wait = WaitElement()
class PurchasePage(BasePage):
def __init__(self):
self.home = HomePage()
self.user_center = UserCenterPage()
self.wait = WaitElement()
@teststep
def wait_check_buy_page(self):
"""以“购买”的xpath @text为依据"""
locator = (By.XPATH,
"//android.widget.TextView[contains(@text,'在线客服')]")
return self.wait.wait_check_element(locator)
@teststep
def wait_check_help_center_page(self):
"""以“帮助中心”的xpath @text为依据"""
locator = (By.XPATH,
"//android.widget.TextView[contains(@text,'帮助中心')]")
return self.wait.wait_check_element(locator)
@teststep
def wait_check_card_page(self):
"""以“优惠购买”的id 为依据"""
locator = (By.ID, self.id_type() + "discount_pay")
return self.wait.wait_check_element(locator)
@teststep
def wait_check_agreement_page(self):
"""以“购买协议”的xpath 为依据"""
locator = (By.XPATH,
"//android.widget.TextView[contains(@text,'购买协议')]")
return self.wait.wait_check_element(locator)
@teststep
def wait_check_pay_confirm_page(self):
"""以“支付确认”的xpath 为依据"""
locator = (By.XPATH,
"//android.widget.TextView[contains(@text,'支付确认')]")
return self.wait.wait_check_element(locator)
@teststep
def wait_check_parent_pay_page(self):
"""以“支付完成”的ID 为依据"""
locator = (By.ID, self.id_type() + "pay_complete")
return self.wait.wait_check_element(locator)
@teststep
def wait_check_magic_page(self):
"""以“支付完成”的ID 为依据"""
locator = (By.XPATH,
"//android.widget.TextView[contains(@text,'在线助教家长端')]")
return self.wait.wait_check_element(locator)
@teststep
def online_server(self):
"""在线客服"""
locator = (By.ID, self.id_type() + 'goToCustomerService')
return self.wait.wait_find_element(locator)
@teststep
def magics(self):
locator = (By.ID, self.id_type() + 'function_des')
return self.wait.wait_find_elements(locator)
@teststep
def upgrade_button(self):
"""马上购买"""
locator = (By.ID, self.id_type() + 'goToUpgrade')
return self.wait.wait_find_element(locator)
@teststep
def discount_buy(self):
"""优惠购买"""
locator = (By.ID, self.id_type() + 'discount_pay')
return self.wait.wait_find_element(locator)
@teststep
def card_type(self):
"""优惠卡类型"""
locator = (By.ID, self.id_type() + 'one')
return self.wait.wait_find_elements(locator)
@teststep
def check_radio(self, card_name):
"""选项按钮"""
locator = (
By.XPATH,
'//android.widget.TextView[contains(@text, "{}")]/../preceding-sibling::'
'android.widget.RadioButton'.format(card_name))
return self.wait.wait_find_element(locator)
@teststep
def card_price(self, card_name):
"""卡片的价格 根据卡的类型获取"""
locator = (
By.XPATH,
'//android.widget.TextView[contains(@text, "{}")]/../following-sibling::'
'android.widget.LinearLayout/android.widget.TextView'.format(
card_name))
return self.wait.wait_check_element(locator)
@teststep
def selected_card(self):
"""已选卡型"""
locator = (By.ID, self.id_type() + 'current_vip_card_hint')
return self.wait.wait_find_element(locator)
@teststep
def direct_buy_button(self):
locator = (By.ID, self.id_type() + 'pay')
return self.wait.wait_find_element(locator)
@teststep
def confirm_pay_button(self):
locator = (By.ID, self.id_type() + 'pay')
return self.wait.wait_find_element(locator)
@teststep
def discount_buy_button(self):
"""优惠购买按钮"""
locator = (By.ID, self.id_type() + 'discount_pay')
return self.wait.wait_find_element(locator)
@teststep
def agreement(self):
"""购买协议"""
locator = (By.ID, self.id_type() + 'pay_agreement')
return self.wait.wait_find_element(locator)
@teststep
def ali_pay_tab(self):
"""支付宝支付"""
locator = (By.XPATH,
'//android.widget.TextView[contains(@text,"支付宝代付")]')
return self.wait.wait_find_element(locator)
@teststep
def wechat_pay_tab(self):
"""微信支付"""
locator = (By.XPATH,
'//android.widget.TextView[contains(@text,"微信代付")]')
return self.wait.wait_find_element(locator)
@teststep
def parent_check_button(self):
locator = (By.ID, self.id_type() + 'pay_agreement')
return self.wait.wait_find_element(locator)
@teststep
def get_all_text_view(self):
"""获取页面所有不为空的文本值"""
locator = (By.CLASS_NAME, 'android.widget.TextView')
ele = self.wait.wait_find_elements(locator)
all_text = [
ele[i].text for i in range(len(ele))
if ele[i].text != '' and ele[i].text is not None
]
return all_text
@teststep
def online_server_ele_check(self):
self.online_server().click()
if self.wait_check_help_center_page():
print('在线助教客服二维码')
self.home.click_back_up_button()
@teststep
def magic_ele_check(self):
all_magics = self.magics()
all_magics[random.randint(0, len(all_magics) - 1)].click()
if self.wait_check_magic_page():
print('法宝详情页....\n')
self.home.click_back_up_button()
if self.wait_check_buy_page():
pass
@teststep
def switch_card(self):
"""切换卡片"""
card_type = self.card_type()
for card in card_type:
card.click()
check_radio = self.check_radio(card.text)
if check_radio.get_attribute('checked') != 'true':
print('❌❌❌ Error-- 选项按钮状态未发生变化')
current_card = self.selected_card()
if card.text.split(' ')[0] != current_card.text:
print('❌❌❌ Error-- 当前卡的类型与所选类型不一致')
else:
print('已选择', current_card.text, '\n')
if '年卡' in card.text:
card_price = self.card_price(card.text)
discount_button = self.discount_buy_button()
if '优惠价' in card_price.text:
if discount_button.get_attribute('enabled') != 'true':
print('❌❌❌ Error-- 有优惠价，但是优惠购买按钮置灰', card.text)
else:
if discount_button.get_attribute('enabled') != 'false':
print('❌❌❌ Error-- 无优惠价，但是优惠购买按钮未置灰', card.text)
@teststep
def check_agreement(self):
agreement = self.agreement()
location = agreement.location
self.driver.tap([
(location['x'] + 520, location['y'] + 50),
])
if self.wait_check_agreement_page():
print('在线助教【提分版】购买协议 .....')
self.home.screen_swipe_down(0.5, 0.5, 0.9, 1500)
self.home.click_back_up_button()
@teststep
def direct_buy(self):
if self.wait_check_card_page():
self.direct_buy_button().click()
if self.wait_check_pay_confirm_page():
self.pay_confirm_page_ele_operate()
self.parent_check_button().click()
self.confirm_pay_button().click()
if self.wait_check_parent_pay_page():
self.ali_pay_tab().click()
time.sleep(2)
self.parent_page_ele_operate()
self.wechat_pay_tab().click()
time.sleep(2)
self.parent_page_ele_operate()
@teststep
def magics_page_ele_operate(self):
"""法宝页面元素信息"""
text = self.get_all_text_view()
if len(text) != 16:
print('❌❌❌ Error-- 页面元素缺失', text)
else:
magic_types = numpy.reshape(text[6:-1], (3, 3))
print("<" + text[0] + '页面>', '\n', '学生:', text[1], '\n', '手机:',
text[2], '\n', '提示:', text[4] + text[5], '\n', '法宝:', '\n',
magic_types, '\n')
@teststep
def buy_page_ele_operate(self):
"""购买页面（优惠卡类型） 页面"""
text = self.get_all_text_view()
print(len(text))
if len(text) not in range(18, 21):
print('❌❌❌ Error-- 页面元素缺失', text)
else:
print(
'<选择优惠卡页面>\n'
'学生:',
text[1],
'\n',
'手机:',
text[2],
'\n',
'提示:',
text[4] + text[5],
'\n',
)
if len(text) == 20:
print(
'优惠卡类型',
'\n',
text[6],
text[7],
'\n',
text[8],
text[9],
'\n',
text[10],
text[11],
text[12],
'\n',
text[13],
text[14],
text[15],
'\n',
'协议:',
text[16],
'\n',
'已选类型:',
text[17],
'\n',
text[18],
text[19],
'\n',
)
else:
print(
'优惠卡类型',
'\n',
text[6],
text[7],
'\n',
text[8],
text[9],
'\n',
text[10],
text[11],
'\n',
text[12],
text[13],
'\n',
'协议:',
text[14],
'\n',
'已选类型:',
text[15],
'\n',
text[16],
text[17],
'\n',
)
@teststep
def pay_confirm_page_ele_operate(self):
text = self.get_all_text_view()
if len(text) != 12:
print('❌❌❌ Error-- 页面元素缺失', text)
else:
print('<支付确认页面>\n'
'学生:', text[1], '\n', '手机:', text[2], '\n', '卡型:', text[6],
'\n', "价格:", text[4] + text[5], '\n', text[7] + ":", '\n',
text[8], text[9], text[10], '\n', text[11], '\n')
@teststep
def parent_page_ele_operate(self):
text = self.get_all_text_view()
if len(text) != 9:
print('❌❌❌ Error-- 页面元素缺失', text)
else:
print(
'<' + text[0] + "页面>",
'\n',
text[1],
text[2],
'\n',
'卡型:',
text[3],
'\n',
'价格:',
text[4] + text[5],
'\n',
text[6],
'\n',
text[7],
'\n',
text[8],
'\n',
)
@teststep
def back_to_home(self):
self.home.click_back_up_button()
if self.wait_check_pay_confirm_page():
self.home.click_back_up_button()
if self.wait_check_card_page():
self.home.click_back_up_button()
if self.wait_check_buy_page():
self.home.click_back_up_button()
if self.user_center.wait_check_user_center_page():
self.home.click_tab_hw()
if self.home.wait_check_home_page():
print('返回主界面')
def setUp(cls):
"""启动应用"""
cls.login_page = LoginPage()
cls.home_page = HomePage()
cls.homework = Homework()
cls.word_dict = WordDictation()
