class WordBookRebuildPage(BasePage): def __init__(self): super().__init__() self.data = WordDataHandlePage() self.public = WorldBookPublicPage() self.wait = WaitElement() self.data_dir = 'app/honor/student/word_book_rebuild/test_data/' @teststep def wait_check_start_page(self): """将'你准备好了吗?'作为 单词本首页 页面检查点""" locator = (By.XPATH, "//android.widget.TextView[contains(@text, '你准备好了吗?')]") return self.wait.wait_check_element(locator, timeout=5) @teststep def wait_check_continue_page(self): """单词继续学习页面检查点""" locator = (By.ID, self.id_type() + "word_continue") return self.wait.wait_check_element(locator, timeout=5) @teststep def wait_check_start_wrong_again_page(self): """错题题再练页面""" locator = (By.ID, self.id_type() + "word_continue") return self.wait.wait_check_element(locator, timeout=5) @teststep def wait_check_game_title_page(self): """游戏标题页面检查点""" locator = (By.ID, self.id_type() + 'tv_title') return self.wait.wait_check_element(locator) @teststep def word_start_button(self): # Go标志按钮 locator = (By.ID, self.id_type() + "word_start") self.wait.wait_find_element(locator).click() time.sleep(3) @teststep def word_continue_button(self): """继续练习按钮""" locator = (By.ID, self.id_type() + "word_continue") self.wait.wait_find_element(locator).click() time.sleep(3) @teststep def total_word(self): """已背单词 数""" locator = (By.ID, self.id_type() + 'total') ele = self.wait.wait_find_element(locator) return int(ele.text) @teststep def confirm_btn(self): """错题再练开始练习按钮""" locator = (By.ID, self.id_type() + 'confirm') return self.wait.wait_find_element(locator) @teststep def write_words_to_file(self, file_name, file_value): """将数据存入文件""" with open(self.data_dir + file_name, 'w', encoding='utf-8') as f: if '.json' in file_name: json.dump(file_value, f, ensure_ascii=False) elif '.txt' in file_name: f.write(','.join(file_value)) @teststep def read_words_info_from_file(self, file_name): """从json文件中读取数据""" file_value = 0 with open(self.data_dir + file_name, 'r', encoding='utf-8') as f: if '.json' in file_name: file_value = json.load(f) elif '.txt' in file_name: file_value = [x for x in f.read().split(',') if x] return file_value @teststep def set_do_right_by_familiar_type(self, familiar_type, group_count): """根据标熟类型设置是否做对""" do_right = 0 if familiar_type in [1, 2, 3]: do_right = False elif familiar_type in [4, 5]: if group_count == 0: do_right = True else: do_right = False return do_right @teststep def group_operate(self, need_recite_count): """分组操作""" if need_recite_count <= 10: # 个数小于10 分为一组 group = [need_recite_count] elif 10 < need_recite_count < 21: # 个数为11-20 分为两组 group = [ floor(need_recite_count / 2), need_recite_count - floor(need_recite_count / 2) ] else: if need_recite_count > 30: # 个数为 20 -30 或者 >30(做30处理) 分三组 need_recite_count = 30 third_division = floor(need_recite_count / 3) second_division = floor((need_recite_count - third_division) / 2) reset_part = need_recite_count - third_division - second_division group = [third_division, second_division, reset_part] return group @teststep def check_new_word_after_recite_process(self, flash_result, group_recite_count, group_count, study_model=1): """校验新词奖励个数""" boundary_value = 28 if study_model == 1 else 17 # 根据学习类型设置边界值 if flash_result: if group_count == 0: if group_recite_count < boundary_value: if len(flash_result[0]) > 10: print('❌❌❌ 新词奖励个数大于10个') else: if len(flash_result[0]) not in range(3, 11): print('❌❌❌ 复习的新词奖励个数不在3-10之间', len(flash_result[0])) else: if group_recite_count < boundary_value: print('❌❌❌ 复习个数小于“{}”, 未有新词奖励'.format(boundary_value)) @teststep def from_wordbook_back_to_home(self): """从单词本中退回主页面""" self.click_back_up_button() GameCommonEle().tips_operate() if self.wait_check_continue_page(): self.click_back_up_button() @teststep def normal_study_new_word_operate(self, stu_id, flash_result, do_right): """单词学习过程""" group_word_answers = flash_result[-1] group_word_explains = list(flash_result[0].values()) star_words = flash_result[2] familiar_explain_ids = list(flash_result[1].keys()) group_new_explain_words = flash_result[3] remove_familiar = list( np.setdiff1d(group_word_explains, familiar_explain_ids)) remove_repeat_words = list( np.setdiff1d(remove_familiar, group_new_explain_words)) remove_repeat_count = len(remove_repeat_words) print('本组所有单词:', group_word_explains) print('本组标星单词:', star_words) print('本组标熟单词:', familiar_explain_ids) print('本组不去新释义做题数:', remove_familiar) print('本组新释义单词:', group_new_explain_words) print('本组去除重复单词数:', remove_repeat_count, '\n') while self.wait_check_game_title_page(): title_ele = self.public.game_title() game_title = title_ele.text mode_id = int( title_ele.get_attribute('contentDescription').split(' ')[1]) if '闪卡练习' in game_title and mode_id == 2: copy_count = FlashCard().flash_copy_model( star_words, group_new_explain_words) if self.wait_check_game_title_page(): if copy_count != len(star_words): self.base_assert.except_error('标星个数与抄写个数不一致') elif '单词拼写(新词)' in game_title or '单词拼写(新释义)' in game_title: spell_count = SpellingWord().new_word_spell_operate( flash_result[1], group_new_explain_words) print('单词拼写个数', spell_count) if self.wait_check_game_title_page(): if spell_count != len(familiar_explain_ids): self.base_assert.except_error('标熟个数与拼写个数不一致') elif '词汇选择(新词)' in game_title: if do_right: # 词汇选择做对操作 VocabularyChoose().right_listen_select_operate( stu_id, remove_repeat_count, group_new_explain_words) else: # 词汇选择随机选择操作 VocabularyChoose().normal_listen_select_operate( remove_repeat_count, group_new_explain_words) elif '连连看' in game_title: MatchingWord().link_link_game_operate(len(remove_familiar), group_word_answers) elif '还原单词' in game_title: if do_right: # 还原单词做对操作 WordRestore().right_restore_word_operate( stu_id, remove_repeat_count, group_new_explain_words) else: # 还原单词做错后做对操作 WordRestore().restore_word_operate( stu_id, remove_repeat_count, group_new_explain_words) elif '单词听写' in game_title: if do_right: # 单词听写做对操作 ListenSpellWordPage().right_listen_spell_operate( stu_id, remove_repeat_count, group_new_explain_words) else: # 单词听写做错后做对操作 ListenSpellWordPage().normal_listen_spell_operate( remove_repeat_count, group_new_explain_words) else: break return remove_repeat_words @teststep def recite_word_operate(self, stu_id, level, wrong_again_words, right_explains): """单词复习过程""" recite_new_explains = self.data.get_recite_new_explains( stu_id, level) # 已学新释义单词,需跳过单词拼写游戏 recite_new_words = self.data.get_word_list_by_explains( stu_id, recite_new_explains) print('新释义解释:', recite_new_explains) print('新释义单词:', recite_new_words) print('新释义单词个数:', len(recite_new_words), '\n') right_words = self.data.get_word_list_by_explains( stu_id, right_explains) print('新词非标熟且全对单词:', right_words) print('新词非标熟且全对个数', len(right_words), '\n') recite_b_explains = self.data.get_recite_level_one_explains( stu_id) # 获取一轮复习单词的个数 recite_b_words = self.data.get_word_list_by_explains( stu_id, recite_b_explains) # 根据解释id获取单词 print('B轮需要复习的解释:', recite_b_explains) print('B轮需要复习的单词:', recite_b_words) print('B轮需要复习的个数:', len(recite_b_words), '\n') vocab_select_words = list(np.setdiff1d(recite_b_words, right_words)) vocab_select_count = len(vocab_select_words) # 词汇选择或者词汇运用的个数 print('B轮词汇选择单词:', vocab_select_words) print('B轮词汇选择个数:', vocab_select_count, '\n') only_apply_explains = list( np.intersect1d(recite_new_explains, right_explains)) # 只有词汇运用的单词 only_apply_words = list(np.intersect1d(recite_new_words, right_words)) print('B轮单独复习词汇运用的解释:', only_apply_explains) print('B轮单独复习词汇运用的单词:', only_apply_words) print('B轮单独复习词汇运用个数:', len(only_apply_words), '\n') recite_b_vocab_apply_words = list( np.hstack((vocab_select_words, only_apply_words))) recite_b_vocab_apply_count = len(recite_b_vocab_apply_words) print('B轮复习词汇运用单词:', recite_b_vocab_apply_words) print('B轮复习词汇运用个数:', recite_b_vocab_apply_count, '\n') recite_b_spell_explains = list( np.setdiff1d(recite_b_explains, recite_new_explains)) # 需要复习单词拼写的单词 recite_b_spell_words = self.data.get_word_list_by_explains( stu_id, recite_b_spell_explains) print('B轮单词拼写解释:', recite_b_spell_explains) print('B轮单词拼写单词:', recite_b_spell_words) print('B轮单词拼写单词个数:', len(recite_b_spell_words), '\n') recite_cde_vocab_apply_explains = self.data.get_recite_level_more_than_one_explains( stu_id, level) # 获取F值=level的解释id recite_cde_vocab_apply_words = self.data.get_word_list_by_explains( stu_id, recite_cde_vocab_apply_explains) # 根据解释id获取单词 print('C/D/E轮词汇运用的解释:', recite_cde_vocab_apply_explains) print('C/D/E轮词汇运用的单词:', recite_cde_vocab_apply_words) print('C/D/E轮词汇运用的个数:', len(recite_cde_vocab_apply_words), '\n') recite_cde_spell_explains = list( np.setdiff1d(recite_cde_vocab_apply_explains, recite_new_explains)) # 需要复习单词拼写的单词 recite_cde_spell_words = self.data.get_word_list_by_explains( stu_id, recite_cde_spell_explains) print('C/D/E轮单词拼写解释:', recite_cde_spell_explains) print('C/D/E轮单词拼写单词:', recite_cde_spell_words) print('C/D/E轮单词拼写单词个数:', len(recite_cde_spell_words), '\n') all_vocab_select_words = vocab_select_words all_vocab_apply_words = list( set( list( np.hstack((recite_b_vocab_apply_words, recite_cde_vocab_apply_words))))) all_spell_words = list( set(list(np.hstack( (recite_b_spell_words, recite_cde_spell_words))))) print('词汇选择总数:', len(all_vocab_select_words)) print('词汇运用总数:', len(all_vocab_apply_words)) print('单词拼写总数:', len(all_spell_words), '\n') vocab_select_group = self.group_operate(len(all_vocab_select_words)) vocab_apply_group = self.group_operate(len(all_vocab_apply_words)) word_spell_group = self.group_operate(len(all_spell_words)) all_group = [vocab_select_group, vocab_apply_group, word_spell_group] max_length = max((len(l) for l in all_group)) reform_group = list( map(lambda x: x + [0] * (max_length - len(x)), all_group)) vocab_select_group = reform_group[0] vocab_apply_group = reform_group[1] word_spell_group = reform_group[2] print('词汇选择分组:', vocab_select_group) print('词汇运用分组:', vocab_apply_group) print('单词拼写分组:', word_spell_group, '\n') for x in range(len(vocab_select_group)): while self.wait_check_game_title_page(): title_ele = self.public.game_title() game_title = title_ele.text print(game_title) mode_id = int( title_ele.get_attribute('contentDescription').split()[1]) if '词汇选择(复习)' in game_title: if len(recite_b_words) < 3: # 若F=1的单词个数小于3 ,则不应出现词汇选择 self.base_assert.except_error('一轮复习单词不足3个,不应出现词汇选择游戏') if not vocab_select_group[x]: self.base_assert.except_error('词汇选择分组为0, 不应出现词汇选择游戏') if mode_id == 1: # mode=1 , 根据单词选解释游戏 VocabularyChoose().vocab_select_choice_explain( vocab_select_group[x], wrong_again_words) else: # mode=2, 根据解释选单词 VocabularyChoose().vocab_select_choice_word( stu_id, vocab_select_group[x], wrong_again_words) if '词汇选择(复习)' in self.public.game_title( ).text: # 判断一组结束后是否还会出现词汇选择游戏 self.base_assert.except_error('词汇选择个数与计算个数不一致!') break elif '词汇运用(复习)' in game_title: if not vocab_apply_group[x]: self.base_assert.except_error('词汇运用分组为0, 不应出现词汇运用游戏') VocabularyChoose().vocab_apply( stu_id, vocab_apply_group[x], right_words, recite_new_explains) # 词汇运用游戏过程 if self.wait_check_game_title_page(): if '词汇运用(复习)' in self.public.game_title( ).text: # 判断一组结束后是否还会出现词汇选择游戏 self.base_assert.except_error('词汇运用组数与计算个数不一致!') break elif '单词拼写(复习)' in game_title: # 单词拼写游戏 if not word_spell_group[0]: self.base_assert.except_error('单词拼写分组为0, 不应出现单词拼写戏') SpellingWord().recite_word_spell_operate( stu_id, word_spell_group[x], recite_new_explains, only_apply_explains) if self.wait_check_game_title_page(): if '单词拼写(复习)' in self.public.game_title().text: self.base_assert.except_error('单词拼写(复习)个数与计算个数不一致') break else: break return len(recite_b_words) + len(recite_cde_vocab_apply_words)
class ProgressPage(BasePage): def __init__(self): self.common = WordDataHandlePage() self.wait = WaitElement() @teststep def wait_check_progress_page(self): locator = (By.XPATH, "//android.widget.TextView[contains(@text,'单词本进度')]") return self.wait.wait_check_element(locator) @teststep def wait_check_sys_label_page(self): locator = (By.XPATH, "//android.widget.TextView[contains(@text,'{}')]".format( '三年级 (系统)')) return self.wait.wait_check_element(locator) @teststep def word_progress_icon(self): """词书进度""" locator = (By.ID, self.id_type() + 'word_statistics') self.wait.wait_find_element(locator).click() @teststep def first_turn(self): """一轮""" locator = (By.ID, self.id_type() + 'first_time') ele = self.wait.wait_find_element(locator) print(ele.text, end=',') @teststep def third_turn(self): """三轮""" locator = (By.ID, self.id_type() + 'three_time') ele = self.wait.wait_find_element(locator) print(ele.text, end=',') @teststep def total(self): """总数""" locator = (By.ID, self.id_type() + 'total') ele = self.wait.wait_find_element(locator) print(ele.text) @teststep def label_name(self): """标签名称""" locator = (By.ID, self.id_type() + 'name') return self.wait.wait_find_element(locator) @teststep def word_statistics(self, name): """单词数据""" locator = ( By.XPATH, "//android.widget.TextView[contains(@text,'{}')]/following-sibling::" "android.widget.TextView".format(name)) return self.wait.wait_find_element(locator).text @teststep def find_pencil_icon(self): try: self.driver.find_element_by_id(self.id_type() + 'img') return True except: return False @teststep def get_word_homework_names(self, stu_id): """获取标签名称""" word_homework_id = self.common.get_all_word_homework_ids(stu_id) word_homework_names = [ self.common.get_word_homework_name(x) for x in word_homework_id ] return word_homework_names @teststep def progress_ele_check(self, stu_id): """页面元素打印""" print("\n----<词书进度页面>----\n") self.first_turn() # 一轮 self.third_turn() # 三轮 self.total() # 总数 label_name = self.get_word_homework_names(stu_id) # 数据库标签名称 label_info = collections.OrderedDict() while True: labels = self.label_name() # 页面标签名 for l in labels: statics = self.word_statistics(l.text) label_info[l.text] = statics if self.wait_check_sys_label_page(): break else: self.screen_swipe_down(0.5, 0.9, 0.5, 2000) self.judge_studying_icon(list(label_info.keys()), label_name) # 进行中 词书判断 sys_labels = [x for x in list(label_info.keys()) if '系统' in x] no_revoke_sys_label = [x for x in sys_labels if '已撤销' not in x] if len(no_revoke_sys_label) != 0: if len(no_revoke_sys_label) != 1: print('❌❌❌ Error-- 有多个系统词书存在,未被撤销词书数量不为1', no_revoke_sys_label) key_list = list( map(lambda x: x[:-7] if '进行中' in x else x, list(label_info.keys()))) word_book_list = list( map(lambda x: x[:-4] if '已撤销' in x else x, key_list)) label_name.sort() word_book_list.sort() if label_name == word_book_list: print("词书标签与数据库一致") for label in list(label_info.keys()): word_data = label_info[label] count = re.findall(r'\d+', word_data) print(label, '\t', word_data) print('一轮单词数:', count[1], ' 三轮单词数:', count[0], ' 单词总数:', count[2], '\n') if '进行中' in label: homework_name = label[:-7] elif '已撤销' in label: homework_name = label[:-4] else: homework_name = label homework_id = self.common.get_word_homework_id_by_name( homework_name) label_id = self.common.get_student_label_id_by_homework_id( stu_id, homework_id) word_list = self.common.get_wordbank_by_label_id(label_id) if int(count[2]) == len(word_list): print('单词总数数验证正确') else: print('❌❌❌ Error-- 总数与数据库数据不匹配', count[2]) self.count_compare(stu_id, homework_id, int(count[1]), int(count[0])) else: print('❌❌❌ Error-- 词书标签与数据库不一致', word_book_list) @teststep def count_compare(self, stu_id, word_homework_id, first_count, third_count): """获取对应熟练度的单词数,并与页面数字比较""" count = self.common.get_words_count(stu_id, word_homework_id) # 返回单词id 与单词熟练度 if count[0] == first_count: print('一轮单词数验证正确') else: print('❌❌❌ Error-- 一轮单词数与数据库不匹配') if count[1] == third_count: print('三轮单词数验证正确') else: print('❌❌❌ Error-- 三轮单词数与数据库不匹配') print('----------------------------------\n') @teststep def judge_studying_icon(self, label_info_keys, label_name): doing_word_book = [x for x in label_info_keys if '进行中' in x] if len(doing_word_book) == 1: if doing_word_book[0][:-7] == label_name[-1]: print('正在练习的词书核实正确', doing_word_book[0][:-7], '\n') else: print('❌❌❌ Error-- 正在练习的词书与数据库不一致!', label_name[-1], '\n') else: print('❌❌❌ Error-- 正在练习的词书与不止一个!', doing_word_book, '\n')
class WordTestResultPage(BasePage): def __init__(self): self.sql_handler = WordTestSqlHandler() self.wait = WaitElement() @teststep def wait_check_test_result_page(self): """测试结果页面检查点""" locator = (By.ID, self.id_type() + 'head') return self.wait.wait_check_element(locator) @teststep def wait_check_again_btn_page(self): locator = (By.ID, self.id_type() + 'again') return self.wait.wait_check_element(locator) @teststep def student_test_id(self): """当前测试id""" locator = (By.ID, self.id_type() + 'head') ele = self.wait.wait_find_element(locator) test_id = json.loads(ele.get_attribute('contentDescription'))['test_id'] return test_id @teststep def result_score(self): """结果得分""" locator = (By.ID, self.id_type() + 'score') ele = self.wait.wait_find_element(locator) return int(ele.text) @teststep def nickname(self): """用户名称""" locator = (By.ID, self.id_type() + 'name') ele = self.wait.wait_find_element(locator) return ele.text @teststep def test_count_summery(self): """测试总数总结""" locator = (By.ID, self.id_type() + 'word_num') ele = self.wait.wait_find_element(locator) return ele.text @teststep def test_record_summery(self): """测试记录总结""" locator = (By.ID, self.id_type() + 'record') ele = self.wait.wait_find_element(locator) return ele.text @teststep def share_btn(self): """打卡按钮""" locator = (By.ID, self.id_type() + 'clock') return self.wait.wait_find_element(locator) @teststep def wrong_again_btn(self): """错题再练按钮""" locator = (By.ID, self.id_type() + 'again') return self.wait.wait_find_element(locator) @teststep def result_back_btn(self): """结果页后退按钮""" locator = (By.ID, self.id_type() + 'back') return self.wait.wait_find_element(locator) @teststep def db_cal_fvalue_dict_operate(self, stu_id, word_dict, game_return, is_right=True): """单词结果页F值计算结果与从数据库获取结果进行对比 :param stu_id: 学生id :param is_right: 是否是正确单词列表 :param game_return: 游戏次数 0 首次测试 >0: 错题再练 :param word_dict: 比较的单词字典 :return cal_dict: F值变化后的dict """ cal_dict, db_dict = {}, {} for x in word_dict: cal_dict[x] = [] db_dict[x] = [] for y in word_dict[x]: fvalue = self.sql_handler.get_fvalue_by_word_explain_id(stu_id, int(x), y[0]) db_dict[x].append((y[0], fvalue)) if is_right: if y[1] < 5: cal_dict[x].append((y[0], y[1]+1)) else: cal_dict[x].append((y[0], y[1])) else: if y[1] == 5 and game_return >= 1: cal_dict[x].append((y[0], y[1] - 1)) else: cal_dict[x].append((y[0], y[1])) print('F值计算结果:', cal_dict) print('F值db结果:', db_dict) if cal_dict != db_dict: self.base_assert.except_error('结果页F值计算结果与数据库结果不一致') @teststep def star_score_check_operate(self, stu_id, pass_word_list, wrong_word_list): """星星积分核对操作 :param stu_id: 学生id :param pass_word_list: 测试通过单词列表 :param wrong_word_list: 测试未通过单词列表 """ star_score_result = self.sql_handler.get_student_test_star_score(stu_id) cal_score_value = sum([len(pass_word_list[x]) for x in pass_word_list]) cal_star_value = sum([len(wrong_word_list[x]) for x in wrong_word_list]) + cal_score_value if int(star_score_result['score']) != cal_score_value: self.base_assert.except_error("积分数与实际计算积分数不一致, 请核实。 student_data表数据为%d, 实际计算数据为%d" % (int(star_score_result['score']), cal_score_value)) if int(star_score_result["star"]) != cal_star_value: self.base_assert.except_error("星星数量与实际计算星星数不一致, 请核实。 student_data表数据为%d, 实际计算数据为%d" % (int(star_score_result['star']), cal_star_value)) @teststeps def check_result_page_data_operate(self, stu_id, nickname, test_word_dict, wrong_count, game_return): """结果页面数据校验 :param game_return: 做题次数 :param wrong_count: 错误单词个数 :param test_word_dict: 测试单词字典信息 :param stu_id: 学生id :param nickname: 学生昵称 """ if self.wait_check_test_result_page(): test_count = len(test_word_dict) page_score = self.result_score() print('测试得分:', page_score, '\n', '学生名称:', self.nickname(), '\n', self.test_count_summery(), '\n', self.test_record_summery()) wrong_word_list = dict_slice(test_word_dict, end=wrong_count) pass_word_list = dict_slice(test_word_dict, start=wrong_count) print('错误单词:', wrong_word_list) print('正确单词:', pass_word_list) self.db_cal_fvalue_dict_operate(stu_id, wrong_word_list, game_return, is_right=False) self.db_cal_fvalue_dict_operate(stu_id, pass_word_list, game_return, is_right=True) test_id = self.student_test_id() db_result_data = self.sql_handler.get_result_data(test_id) db_right_count = db_result_data[0] db_total_count = db_right_count + db_result_data[1] db_score = int(db_result_data[3]) split_time = db_result_data[2].split(':') db_spend_time = int(split_time[0] * 60) + int(split_time[1]) + (1 if int(split_time[2]) >= 30 else 0) pass_count = 0 if db_score < 90 else db_right_count if db_score != page_score: self.base_assert.except_error('测试分数与计算分数不一致,应为%d, 页面为%d' % (db_score, page_score)) if self.nickname() != nickname: self.base_assert.except_error("当前页面昵称与设置中昵称不一致") word_count = int(re.findall(r'\d+', self.test_count_summery())[0]) if db_total_count != word_count: self.base_assert.except_error("页面统计测试总数与实际个数不一致, 页面为%d,实际为%d" % (word_count, test_count)) record_info = re.findall(r'\d+', self.test_record_summery()) studied_words_count = WordDataHandlePage().get_student_studied_words_count(stu_id) if studied_words_count != int(record_info[0]): self.base_assert.except_error("页面已背单词个数与实际已背数量不一致, 页面为%d, 实际为%d" % (int(record_info[0]), studied_words_count)) if pass_count != int(record_info[1]): self.base_assert.except_error("页面测试通过单词个数与实际通过数量不一致, 页面为%d, 实际为%d" % (int(record_info[1]), pass_count)) if db_spend_time != int(record_info[2]): self.base_assert.except_error("页面统计时间与实际用时不一致,页面为%d, 实际为%d" % (int(record_info[2]), db_spend_time)) # self.star_score_check_operate(stu_id, pass_word_list, wrong_word_list) if page_score == 100: if self.wait_check_again_btn_page(): self.base_assert.except_error("得分为100分, 但是错题再练可点击") self.share_btn().click() GameCommonEle().share_page_operate() return wrong_word_list
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()
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('返回主界面')
class WordTestPage(BasePage): def __init__(self): self.home = HomePage() self.sql_handler = WordTestSqlHandler() self.spell = SpellWordGame() self.wait = WaitElement() @teststep def wait_check_no_test_word_page(self): """测试次数不足页面检查点""" locator = (By.XPATH, '//android.widget.Button[contains(@text,"确定")]') return self.wait.wait_check_element(locator) @teststep def wait_check_start_test_page(self): """开始测试页面检查点""" locator = (By.XPATH, '//android.widget.Button[contains(@text,"开始复习")]') return self.wait.wait_check_element(locator) @teststep def wait_check_preview_word_page(self): """单词预览页面检查点""" locator = (By.ID, self.id_type() + "start") return self.wait.wait_check_element(locator) @teststep def wait_check_select_word_count_page(self): """单词测试数页面检查点""" locator = (By.ID, self.id_type() + "num_hint") return self.wait.wait_check_element(locator) @teststep def wait_check_test_game_page(self): """单词测试游戏页面检查点""" locator = (By.ID, self.id_type() + "time") return self.wait.wait_check_element(locator) @teststep def word_count_select_tab(self): """单词测试数选项""" locator = ( By.XPATH, '//android.support.v7.widget.RecyclerView[contains(@resource-id, "test_num_container")]/' 'android.view.ViewGroup/android.widget.TextView') return self.wait.wait_find_elements(locator) @teststep def word_test_type(self): """测试类型""" locator = ( By.XPATH, "//android.support.v7.widget.RecyclerView[contains(@resource-id, 'test_type_container')]/" "android.view.ViewGroup/android.widget.TextView") return self.wait.wait_find_elements(locator) @teststep def click_word_test_tab(self): """点击单词测试按钮""" locator = (By.ID, self.id_type() + "word_test") self.wait.wait_find_element(locator).click() @teststep def click_confirm_btn(self): """点击复习或者确定按钮""" locator = (By.ID, self.id_type() + "next") self.wait.wait_find_element(locator).click() @teststep def click_start_test_btn(self): """点击开始测试按钮""" locator = (By.ID, self.id_type() + "start") self.wait.wait_find_element(locator).click() @teststep def preview_explain(self): """预览单词""" locator = (By.ID, self.id_type() + "explain") return self.wait.wait_find_elements(locator) @teststep def preview_voice_icon(self, explain): """预览单词喇叭图标""" locator = (By.XPATH, '//android.widget.TextView[@text="{}"]/preceding-sibling' '::android.widget.ImageView'.format(explain)) return self.wait.wait_find_element(locator) @teststep def preview_word(self, explain): """预览单词解释""" locator = (By.XPATH, '//android.widget.TextView[@text="{}"]/preceding-sibling::' 'android.widget.TextView[contains(@resource-id,"word")]'. format(explain)) return self.wait.wait_find_element(locator) @teststep def test_select_page_operate(self, tab_index): """单词测试数页面操作过程""" if self.wait_check_select_word_count_page(): select_tab = self.word_count_select_tab() test_type = self.word_test_type() for x in select_tab: if '50' in x.text: if x.get_attribute('selected') != 'true': self.base_assert.except_error('单词个数没有默认选择50') break if test_type[0].get_attribute("selected") != "true": self.base_assert.except_error("默写类型没有被选中") test_count = int(select_tab[tab_index].text) print('test_count:', test_count) if test_count is None: self.base_assert.except_error('未获取单词个数') select_tab[tab_index].click() self.click_confirm_btn() return test_count @teststep def get_test_word_list(self, fvalue_glt_3_words, test_fail_words, test_pass_words, tab_index): """获取测试单词数 :param fvalue_glt_3_words: 未测且F值大于3的单词 :param test_fail_words: 测试失败单词 :param test_pass_words: 测试通过单词 :param tab_index: 选择题目个数 """ # 测试数量小于未测单词数 取未测单词数[:测试数量] # 测试数量大于未测单词数 需补充测试未通过单词 获取补充数量 测试数-未测单词数 # 若补充数小于测试未通过数, 去补充数,测试单词未未测+未通过[:补充] # 若补充数大于测试未通过单词数,需补充测试通过单词 获取补充数量2 补充数 - 未通过单词 # 若补充数量2小于测试通过单词数, 测试数为 未测 + 未通过 + 通过[:补充数量2] # 若补充数量2大于测试通过单词数, 测试数为 未测 + 未通过 + 通过 test_count = self.test_select_page_operate(tab_index) dcg_value = test_count - len(fvalue_glt_3_words) if dcg_value <= 0: test_word_list = dict_slice(fvalue_glt_3_words, end=test_count) else: test_word_list = fvalue_glt_3_words if dcg_value <= len(test_fail_words): fail_words = dict_slice(test_fail_words, end=dcg_value) test_word_list.update(fail_words) else: test_word_list.update(test_fail_words) ddf_value = dcg_value - len(test_pass_words) if ddf_value <= 0: pass_words = dict_slice(test_pass_words, end=dcg_value) else: pass_words = test_pass_words test_word_list.update(pass_words) return test_word_list if test_word_list else {} @teststeps def check_preview_word_operate(self, test_word_info): """预览单词校验操作""" # 循环遍历单词与解释,对比已获得的测试单词,判断是否在测试列表中,解释是否合并或者相同 test_answer = {} word_id_list = [] if self.wait_check_preview_word_page(): explain_list = [] while len(explain_list) < len(test_word_info): if self.wait_check_preview_word_page(): preview_explain = self.preview_explain() for i, x in enumerate(preview_explain): if x.text in explain_list: continue else: word = self.preview_word(x.text) word_id = word.get_attribute('contentDescription') word_id_list.append(word_id) explain_list.append(x.text) test_answer[x.text] = word.text if word_id not in list(test_word_info.keys()): self.base_assert.except_error( '此单词不在测试单词列表内, 但是出现在预览列表中 ' + word_id) else: explain_info = test_word_info[word_id] query_explains = self.sql_handler.get_word_explain_list( explain_info) page_explain_list = x.text.split(';') page_explain_list.sort() query_explains.sort() if query_explains != page_explain_list: self.base_assert.except_error( "页面单词不等于单词解释集合 " + word_id) voice_icon = self.preview_voice_icon(x.text) voice_icon.click() self.screen_swipe_up(0.5, 0.9, 0.45, 1000) print('页面单词id列表, ', word_id_list) return test_answer, word_id_list @teststeps def play_test_word_spell_operate(self, test_count, test_answer, do_pass, no_wrong=False): """单词默写游戏过程 :param no_wrong: 是否做全对 :param test_count: 测试单词个数 :param test_answer: 预览时记录的答案 :param do_pass: 测试是否达到90% """ if self.wait_check_test_game_page(): game_count = self.spell.rest_bank_num() if test_count != game_count: self.base_assert.except_error("默写数量与测试单词数不一致") if no_wrong: wrong_count = 0 else: if do_pass: wrong_count = floor(game_count * 0.1) else: wrong_count = floor(game_count * 0.1) + 2 timer = [] game_word_id_list = [] wrong_index = list(range(wrong_count)) for x in range(game_count): self.spell.next_btn_judge( 'false', self.spell.fab_commit_btn) # 判断下一题按钮状态 self.spell.rate_judge(game_count, x) # 校验剩余题数 explain = self.spell.word_explain().text print('解释:', explain) if x in wrong_index: self.spell.word_spell_play_process(game_mode=1) self.spell.next_btn_operate("true", self.spell.fab_commit_btn) if not self.spell.wait_check_right_answer_page(): self.base_assert.except_error("拼写单词错误,提交后未显示正确答案" + explain) else: print("正确答案:", self.spell.right_answer_word()) else: right_answer = test_answer[explain] self.spell.word_spell_play_process( game_mode=1, do_right=True, right_answer=right_answer) self.spell.next_btn_operate("true", self.spell.fab_commit_btn) print('正确答案:', right_answer) mine_input_word = self.spell.spell_word() word_id = mine_input_word.get_attribute('contentDescription') game_word_id_list.append(word_id) print('输入答案:', mine_input_word.text[::2]) timer.append(self.spell.bank_time()) self.spell.click_voice() self.spell.fab_next_btn().click() print('-' * 30, '\n') self.spell.judge_timer(timer) # 时间校验 return wrong_count, game_word_id_list