def check_word_is_only_has_vocab_apply(self, explain_id, new_explain_words,
stu_id):
"""查看单词是否只有词汇运用"""
if explain_id in new_explain_words:
print('此单词是新释义单词')
word_level = WordDataHandlePage().get_level_by_explain_id(
explain_id, stu_id)
lager_level_count = WordDataHandlePage(
).check_has_other_studied_explain(explain_id, stu_id, word_level)
if lager_level_count:
print('❌❌❌ 存在F值比此单词大的解释，单词复习只有词汇运用，不应在此游戏中出现')
def test_have_different_teacher(self):
"""测试拥有不同老师，不同班级的情况"""
if self.home.wait_check_home_page():
test_class_num = VANCLASS_ID
van_num = test_class_num.copy()
QuitAddClass().apply_class_operate(van_num)
web_driver = Driver()
web_driver.set_driver()
for x in TEACHER_ACCOUNT:
AssignWord().assign_wordbook_operate(test_class_num, x, STU_PASSWORD)
LoginWebPage().logout_operate()
web_driver.quit_web()
if self.home.wait_check_home_page():
stu_info = UserCenterPage().get_user_info()
stu_id = stu_info[0]
teacher_trans_ids = WordDataHandlePage().get_teacher_words_trans_id(stu_id)
if self.home.wait_check_home_page():
self.home.click_hk_tab(1) # 点击 背单词
if self.word_rebuild.wait_check_start_page(): # 开始页面检查点
self.word_rebuild.word_start_button() # 点击 Go按钮
word_info = FlashCard().scan_game_operate(is_exit=True)
WorldBookPublicPage().check_word_order_is_right(teacher_trans_ids, word_info[0])
if self.word_rebuild.wait_check_continue_page():
self.word_rebuild.click_back_up_button()
def test_have_class(self, test_class_num):
"""测试有老师的情况， 一个班或者多个班的情况"""
if self.home.wait_check_home_page():
van_num = test_class_num.copy()
QuitAddClass().apply_class_operate(van_num)
web_driver = GetWebDriver()
web_driver.set_driver()
AssignWord().assign_wordbook_operate(test_class_num,
TEACHER_ACCOUNT[0],
STU_PASSWORD)
web_driver.quit_web()
if self.home.wait_check_home_page():
stu_info = UserCenterPage().get_user_info()
stu_id = stu_info[0]
teacher_trans_ids = WordDataHandlePage(
).get_teacher_words_trans_id(stu_id)
if self.home.wait_check_home_page():
self.home.click_hk_tab(1) # 点击 背单词
if self.word_rebuild.wait_check_start_page(): # 开始页面检查点
self.word_rebuild.word_start_button() # 点击 Go按钮
word_info = FlashCard().scan_game_operate(is_exit=True)
WorldBookPublicPage().check_word_order_is_right(
teacher_trans_ids, word_info[0])
if self.word_rebuild.wait_check_continue_page():
self.word_rebuild.click_back_up_button()
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.data = WordDataHandlePage()
cls.mine = MineWordsPage()
cls.login.app_status() # 判断APP当前状态
BasePage().set_assert(cls.base_assert)
def test_new_word(self, do_right=False):
"""测试新词"""
if self.home.wait_check_home_page():
# 取消所有班级布置的单词
# for x in TEACHER_ACCOUNT:
# AssignWord().revoke_van_class_wordbook_operate(x, STU_PASSWORD)
# LoginWebPage().logout_operate()
# QuitAddClass().quit_all_class_operate()
stu_info = UserCenterPage().get_user_info() # 获取学生信息
stu_id = stu_info[0]
WordDataHandlePage().clear_student_word_data(stu_id) # 清除学生已学单词记录
self.word_info = {}
# WordDataHandlePage().clear_word_finish_date(stu_id)
if self.home.wait_check_home_page():
self.home.click_hk_tab(1) # 点击 背单词
if self.word_rebuild.wait_check_start_page(): # 开始页面检查点
self.word_rebuild.word_start_button() # 点击 Go按钮
elif self.word_rebuild.wait_check_continue_page(
): # 若为继续页面，则说明未清除缓存
self.base_assert.except_error('缓存未清除成功')
self.word_rebuild.word_continue_button()
recite_words, all_words = [], [] # 复习单词, 新词
for x in range(2):
if self.word_rebuild.wait_check_game_title_page():
# 闪卡学习过程 返回闪卡题数，标星标熟
flash_result = FlashCard().flash_study_model(
stu_id, self.word_info, x, do_right)
if flash_result:
group_new_explain_words = flash_result[
3] # 每组新释义单词
all_words.append(len(
flash_result[0])) # 把每组新词个数加入新词数组
self.new_explain_words.extend(
group_new_explain_words) # 将新释义单词加入新释义数组中
# 其他新词游戏过程
self.word_rebuild.normal_study_new_word_operate(
stu_id, flash_result, do_right) # 游戏过程
if ResultPage().wait_check_result_page():
# 结果页单词统计核实
ResultPage().result_page_handle(
len(self.word_info), len(self.new_explain_words),
len(recite_words), x)
self.word_rebuild.click_back_up_button()
self.home.tips_operate_commit()
def test_no_class_word_data(self):
"""测试没有班级时候的"""
if self.home.wait_check_home_page():
QuitAddClass().quit_all_class_operate()
stu_info = UserCenterPage().get_user_info()
stu_id = stu_info[0]
sys_trans_ids = WordDataHandlePage().get_sys_words_trans_id(stu_id)
if self.home.wait_check_home_page():
self.home.click_hk_tab(1) # 点击 背单词
if self.word_rebuild.wait_check_start_page(): # 开始页面检查点
self.word_rebuild.word_start_button() # 点击 Go按钮
word_info = FlashCard().scan_game_operate(is_exit=True)
WorldBookPublicPage().check_word_order_is_right(
sys_trans_ids, word_info[0], sys_only=True)
if self.word_rebuild.wait_check_continue_page():
self.word_rebuild.click_back_up_button()
def right_listen_spell_operate(self, stu_id, bank_count, new_explain_words):
"""单词听写做对操作"""
print('===== 🌟🌟 单词听写模式(新词)(一次做对) 🌟🌟 =====\n')
for x in range(bank_count):
self.next_btn_judge('false', self.fab_commit_btn) # 下一题 按钮 判断加 点击操作
explain_id = self.word_public.get_explain_id(self.input_wrap_side())
right_answer = WordDataHandlePage().get_word_by_explain_id(stu_id, explain_id)
for alpha in list(right_answer):
self.key.games_keyboard(alpha) # 输入单词的大写字母
self.next_btn_operate('true', self.fab_commit_btn) # 下一题 按钮 判断加 点击操作
explain = self.word_explain()
if explain_id in new_explain_words:
print('❌❌❌ 此单词为新释义，不应出现单词听写游戏')
print('解释：', explain.text)
print('我输入的：', right_answer)
self.next_btn_operate('true', self.fab_next_btn) # 下一题
time.sleep(2)
print('-' * 30, '\n')
time.sleep(5)
def __init__(self):
self.common = WordDataHandlePage()
self.wait = WaitElement()
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 VocabularyChoose(VocabChoiceGame):
"""词汇选择"""
def __init__(self):
self.data = WordDataHandlePage()
@teststeps
def normal_listen_select_operate(self, bank_count, new_explain_words):
"""《词汇选择》 - 听音选词模式 具体操作"""
print('===== 🌟🌟 词汇选择(新词) 听音选词模式(第一遍选错，第二遍选择正确) 🌟🌟=====\n')
print('题目个数：', bank_count)
answer_word, all_words = [], []
while len(all_words) < bank_count:
self.next_btn_judge('false', self.fab_next_btn)
self.listen_choice_speak_icon().click() # 点击发音按钮
options = self.vocab_options() # 获取当前页面所有选项
if not answer_word: # 正确答案列表为空
opt_index = random.randint(0, len(options) - 1) # 随机选择一个选项
opt_text = options[opt_index].text
options[opt_index].click()
self.next_btn_judge('true', self.fab_next_btn) # 检查下一步按钮的状态
print('选择答案为：', opt_text)
if self.wait_check_explain_page(): # 检验是否出现解释页面
explain = self.vocab_word_explain()
explain_id = explain.get_attribute('contentDescription')
if explain_id in new_explain_words:
self.base_assert.except_error('此单词为新释义，不应出现词汇选择游戏')
print('解释:', explain.text)
else:
self.base_assert.except_error('解释文本未出现')
right_answer = self.vocab_right_answer() # 正确答案
if right_answer == opt_text:
print('选择正确')
all_words.append(right_answer)
else:
print('选择错误，正确答案为', right_answer)
answer_word.append(right_answer)
else: # 正确答案列表不为空-- 上一题选择错误
for y in options:
if y.text == answer_word[0]: # 点击正确答案
y.click()
self.next_btn_judge('true', self.fab_next_btn) # 检查下一步按钮的状态
if self.wait_check_explain_page():
explain = self.vocab_word_explain()
explain_id = explain.get_attribute('contentDescription')
if explain_id in new_explain_words:
self.base_assert.except_error('此单词为新释义，不应出现词汇选择游戏')
all_words.append(y.text)
print('答案正确：%s' % answer_word[0])
print('解释：%s' % explain.text)
else:
self.base_assert.except_error('Error-- 解释文本未出现')
break
answer_word.clear()
self.sound_icon().click()
self.fab_next_btn().click() # 下一题 按钮 状态判断 加点击
time.sleep(2)
print('-' * 30, '\n')
@teststeps
def right_listen_select_operate(self, stu_id, bank_count, new_explain_words):
print('===== 🌟🌟 词汇选择(新词) 听音选词模式(一次做对模式) 🌟🌟 =====\n')
for x in range(bank_count):
self.next_btn_judge("false", self.fab_next_btn) # 下一题 按钮 状态判断 加点击
voice_btn = self.listen_choice_speak_icon()
explain_id = voice_btn.get_attribute('contentDescription')
if explain_id in new_explain_words:
self.base_assert.except_error('此单词为新释义，不应出现词汇选择游戏')
right_word = self.data.get_word_by_explain_id(stu_id, explain_id)
for y in self.vocab_options():
if y.text == right_word:
print('选择选项：', y.text)
y.click()
if not self.wait_check_explain_page():
self.base_assert.except_error('点击选项未出现解释文本！')
else:
print("解释：", self.vocab_word_explain().text)
break
self.sound_icon().click()
self.fab_next_btn().click() # 下一题 按钮 状态判断 加点击
time.sleep(2)
print('-' * 30, '\n')
@teststeps
def vocab_select_choice_explain(self, bank_count, wrong_again_words):
"""《词汇选择》 - 选解释模式
:param bank_count: 题目个数
:param wrong_again_words: 错题再练单词
"""
print('====== 🌟🌟 词汇选择 - 根据单词选解释模式（复习）🌟🌟 =====\n')
recite_words = []
for x in range(bank_count + 2):
self.next_btn_operate('false', self.fab_next_btn) # 下一题 按钮 判断加 点击操作
self.sound_icon().click() # 点击发音按钮
word = self.vocab_question() # 题目
print('题目:', word.text)
explain_id = word.get_attribute('contentDescription') # 获取正确解释id
if explain_id in recite_words:
self.base_assert.except_error('单词已选过， 再次出现')
right_explain = self.data.get_explain_by_id(explain_id) # 根据id获取正确解释文本
options = self.vocab_options() # 遍历选项，点击和正确答案一样的解释
for y in options:
if x in [2, 3]: # 次序为【2,3】连续选择错误
if right_explain not in y.text:
if x == 2:
wrong_again_words.append(explain_id)
print('选择错误答案：', y.text)
print('正确答案为:', right_explain)
y.click()
break
elif right_explain in y.text:
print('选择答案：', y.text)
recite_words.append(explain_id)
y.click()
break
print('正确答案：', right_explain)
self.fab_next_btn().click() # 下一题 按钮 状态判断 加点击
time.sleep(2)
print('-'*30, '\n')
@teststeps
def vocab_select_choice_word(self, stu_id, bank_count, wrong_again_words):
"""《词汇选择》 - 根据解释选单词"""
recite_words = []
print('===== 🌟🌟 词汇选择-选单词模式（复习）🌟🌟 =====\n')
for x in range(bank_count + 2):
self.next_btn_judge('false', self.fab_next_btn) # 下一题 按钮 判断加 点击操作
item = self.vocab_question() # 题目
print('题目:', item.text)
explain_id = item.get_attribute('contentDescription')
if explain_id in recite_words:
self.base_assert.except_error('单词已选过， 再次出现')
right_word = self.data.get_word_by_explain_id(stu_id, explain_id) # 根据解释id获取正确单词
options = self.vocab_options() # 遍历选项，点击和word一样的单词
for y in options:
if x in [2, 3]: # 次序为【2,3】连续选择错误
if y.text != right_word:
if x == 2:
wrong_again_words.append(explain_id)
print('选择错误答案：', y.text)
print('正确答案为:', right_word)
y.click()
break
elif y.text == right_word:
print('选择答案：', y.text)
recite_words.append(explain_id)
y.click()
break
if self.wait_check_voice_page():
self.sound_icon().click()
else:
self.base_assert.except_error(' Error-- 声音按钮未出现')
self.fab_next_btn().click() # 下一题 按钮 状态判断 加点击
time.sleep(2)
print('-'*30, '\n')
@teststeps
def vocab_apply(self, stu_id, bank_count, right_words, recite_new_explain_words):
"""词汇运用"""
print('===== 🌟🌟 词汇运用 --句子选单词模式(复习) 🌟🌟 =====\n')
recite_words = []
for x in range(bank_count):
self.next_btn_judge('false', self.fab_next_btn)
item = self.vocab_question() # 题目
print('题目：%s' % item.text)
explain_id = item.get_attribute('contentDescription') # 根据题目获取explain——id
if explain_id in recite_words:
self.base_assert.except_error('单词已复习过， 单词未去重!')
if explain_id in right_words and explain_id not in recite_new_explain_words:
self.base_assert.except_error('单词新词时做全对， 复习时不为新释义单词， 不应出现词汇运用游戏')
right_answer = self.data.get_word_by_explain_id(stu_id, explain_id) # 根据解释id获取正确单词
self.apply_hint_button().click() # 点击提示按钮
self.next_btn_judge('false', self.apply_hint_button) # 提示按钮 状态判断
if not self.wait_vocab_apply_explain_page():
self.base_assert.except_error('点击提示后未发现句子解释文本')
else:
sentence_explain = self.apply_sentence_explain()
print('单词解释：', sentence_explain)
for y in self.vocab_options():
if y.text == right_answer:
recite_words.append(explain_id)
print('选择答案：', y.text)
y.click()
break
if self.wait_check_voice_page():
self.sound_icon().click()
else:
self.base_assert.except_error('Error-- 声音按钮未出现')
self.fab_next_btn().click() # 下一题 按钮 状态判断 加点击
time.sleep(2)
print('-'*30, '\n')
def __init__(self):
self.data = WordDataHandlePage()
def flash_study_model(self, stu_id, word_info, group_count, do_right):
""":param word_info: 记录今日所做的所有新
:param group_count: 做的组数
:param stu_id: 学生id
:param do_right: 是否做全对
"""
"""学习模式 新词操作"""
familiar_words, all_words = {}, {}
group_word_answer = {}
star_words, group_new_explain_words = [], []
index = 0
while self.wait_check_flash_study_page():
if index == 0:
print('===== 🌟🌟 闪卡练习 学习模式 🌟🌟 =====\n')
word = self.english_study()
if self.wait_check_explain_page():
self.next_btn_judge('true', self.fab_next_btn)
explain = self.study_word_explain() # 解释
sentence = self.study_sentence()
sentence_explain = self.study_sentence_explain()
sentence_author = self.author()
explain_id = explain.get_attribute('contentDescription').split(
' ')[0]
print('单词：', word, '\n', '解释：', explain.text, '\n', '句子：',
sentence, '\n', '句子解释：', sentence_explain, '\n', '推荐老师：',
sentence_author, '\n')
if '新释义' in self.game_title().text:
if not self.wait_check_dragger_btn():
self.base_assert.except_error('★★★ 单词为新释义吗, 但是未发现拖拽按钮')
else:
if word in list(word_info.keys()):
self.old_explain_tab_ele_check(word_info, word)
group_new_explain_words.append(explain_id)
if WordDataHandlePage().check_has_other_studied_explain(
stu_id, explain_id):
print('此单词为新释义单词')
else:
print('❌❌❌ 该单词不为新释义单词，但是标题出现新释义字样')
if word in list(all_words.keys()): # 判断单词是否去重
print('❌❌❌ 本组已存在本单词，单词未去重！')
else:
all_words[word] = explain_id
group_word_answer[explain.text] = word
if word not in list(word_info.keys()):
word_info[word] = {
"explain_id": [explain_id],
'explain': [explain.text],
'sentence': [sentence],
'sentence_explain':
[sentence_explain + sentence_author],
}
else:
explain_id_list = word_info[word]['explain_id']
if explain_id in explain_id_list:
print('❌❌❌ 该解释已作为新词出现过')
else:
word_info[word]['explain_id'].append(explain_id)
word_info[word]['explain'].append(explain.text)
word_info[word]['sentence'].append(sentence)
word_info[word]['sentence_explain'].append(
sentence_explain + sentence_author)
self.pattern_switch() # 切换到 全英模式
if self.wait_check_explain_page(): # 校验是否成功切换
self.base_assert.except_error('❌❌❌ 切换全英模式， 依然存在解释')
self.pattern_switch() # 切换回 英汉模式
if not do_right:
if index % 2 == 0: # 标熟
if index == 2:
self.familiar_button().click()
if self.familiar_button().text != '取消熟词':
self.base_assert.except_error(
'❌❌❌ 点击熟词后内容未发生变化')
self.familiar_button().click()
if self.familiar_button().text != '设置熟词':
self.base_assert.except_error(
'❌❌❌ 点击熟词后内容未发生变化')
self.familiar_button().click()
self.check_alert_tip_operate(
index, group_count) # 判断首次标熟是否有提示
familiar_words[explain_id] = word
if index in [0, 1, 3]:
if index == 1:
self.star_button().click() # 标星
if self.star_button().get_attribute(
'selected') != 'true':
self.base_assert.except_error(
'❌❌❌ 点击标星按钮后，按钮未点亮')
self.star_button().click()
if self.star_button().get_attribute(
'selected') != 'false':
self.base_assert.except_error(
'❌❌❌ 取消标星后，按钮未置灰')
self.star_button().click() # 标星
self.check_alert_tip_operate(
index, group_count) # 判断首次标星是否有提示
star_words.append(explain_id)
else:
self.base_assert.except_error('❌❌❌ 默认不是英汉模式')
self.next_btn_operate('true', self.fab_next_btn)
# self.next_word(index, word)
index += 1
print('-' * 30, '\n')
return all_words, familiar_words, star_words, group_new_explain_words, group_word_answer
def flash_different_familiar_operate(self, stu_id, word_info,
familiar_type, group_count,
first_group_familiar,
word_has_different_explain):
index, familiar_count = 0, 0
familiar_words, all_words = {}, {}
group_new_explain_words = []
while self.wait_check_flash_study_page():
if index == 0:
if familiar_type == 1:
print('===== 🌟🌟 第一组单词标熟，第二组该单词不标熟（全对） 🌟🌟 =====\n')
elif familiar_type == 2:
print('===== 🌟🌟 第一组单词不标熟，单词做错，第二组该单词标熟 🌟🌟 =====\n')
elif familiar_type == 3:
print('===== 🌟🌟 第一组单词不标熟，单词做错， 第二组该单词不标熟（全对） 🌟🌟 =====\n')
elif familiar_type == 4:
print('===== 🌟🌟 第一组单词不标熟，单词全对， 第二组该单词标熟 🌟🌟 =====\n')
elif familiar_type == 5:
print('===== 🌟🌟 第一组单词不标熟, 单词全对， 第二组该单词不标熟（全对） 🌟🌟 =====\n')
word = self.english_study()
self.next_btn_judge('true', self.fab_next_btn)
explain = self.study_word_explain() # 解释
explain_id = explain.get_attribute('contentDescription').split(
' ')[0]
if '新释义' in self.game_title().text:
group_new_explain_words.append(explain_id)
if WordDataHandlePage().check_has_other_studied_explain(
stu_id, explain_id):
print('此单词为新释义单词')
else:
print('❌❌❌ 该单词不为新释义单词，但是标题出现新释义字样')
if word in list(all_words.keys()): # 判断单词是否去重
print('❌❌❌ 本组已存在本单词，单词未去重！')
else:
all_words[word] = explain_id
if word not in list(word_info.keys()):
word_info[word] = [explain_id]
else:
explain_id_list = word_info[word]
if explain_id in explain_id_list:
print('❌❌❌ 该解释已作为新词出现过')
else:
word_info[word].append(explain_id)
print('单词：', word, '\n', '解释：', explain.text, '\n', '句子：',
self.study_sentence(), '\n', '句子解释：',
self.study_sentence_explain(), '\n', '推荐老师：', self.author(),
'\n')
self.pattern_switch() # 切换到 全英模式
if self.wait_check_explain_page(): # 校验是否成功切换
print('❌❌❌ 切换全英模式， 依然存在解释')
self.pattern_switch() # 切换回 英汉模式
if familiar_type == 1:
if group_count == 0:
familiar_count = self.first_group_familiar_operate(
word, explain_id, word_has_different_explain,
familiar_words, familiar_count)
elif group_count == 1:
familiar_count = self.second_group_not_familiar_operate(
word, explain_id, first_group_familiar, familiar_words,
familiar_count)
elif familiar_type == 2 or familiar_type == 4:
if group_count == 0:
familiar_count = self.first_group_not_familiar_operate(
word, explain_id, word_has_different_explain,
familiar_words, familiar_count)
elif group_count == 1:
familiar_count = self.second_group_familiar_operate(
word, explain_id, first_group_familiar, familiar_words,
familiar_count)
elif familiar_type == 3 or familiar_type == 5:
if group_count == 0:
familiar_count = self.first_group_not_familiar_operate(
word, explain_id, word_has_different_explain,
familiar_words, familiar_count)
elif group_count == 1:
familiar_count = self.second_group_not_familiar_operate(
word, explain_id, first_group_familiar, familiar_words,
familiar_count)
# self.next_word(index, word)
self.next_btn_operate('true', self.fab_next_btn)
index += 1
print('-' * 30, '\n')
return all_words, familiar_words, 0, group_new_explain_words
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/'
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)
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
def __init__(self):
super().__init__()
self.data = WordDataHandlePage()
self.key = Keyboard()
self.word_public = WorldBookPublicPage()
class SpellingWord(SpellWordGame):
"""单词拼写"""
def __init__(self):
super().__init__()
self.data = WordDataHandlePage()
self.key = Keyboard()
self.word_public = WorldBookPublicPage()
@teststep
def spell_right_word_operate(self, word):
"""单词拼写做对操作"""
# self.hint_ele_operate(word)
# self.key.games_keyboard('backspace')
print('单词:', word)
for j in range(0, len(word)):
self.keyboard_operate(j, word[j]) # 点击键盘 具体操作
@teststeps
def new_word_spell_operate(self, familiar_word, new_explain_words):
"""单词拼写 - 《默写模式》游戏过程"""
print('===== 🌟🌟 单词拼写 新词 🌟🌟 ======\n')
print('标熟单词：', familiar_word, '\n')
all_words = []
value = 0
index = 0
while self.wait_check_normal_spell_page():
explain_ele = self.word_explain() # 解释
explain = explain_ele.text
explain_id = self.word_public.get_explain_id(explain_ele)
self.next_btn_judge('false', self.fab_commit_btn) # 下一题 按钮 状态判断
if explain_id in new_explain_words:
if '新释义' not in self.game_title().text:
print('❌❌❌ 该单词为新释义，但是标题没有显示新释义字样')
print('解释：', explain)
if explain in all_words:
print('❌❌❌ 该单词在拼写单词中已经出现过！')
else:
all_words.append(explain)
if explain_id not in list(familiar_word.keys()):
print('❌❌❌ 单词未标熟，但是出现拼写', explain)
else:
value = familiar_word[explain_id]
self.spell_right_word_operate(value)
self.next_btn_operate('true', self.fab_commit_btn) # 下一题 按钮 状态判断 加点击
answer = self.spell_word().text[::2] # 最终答案
if answer != value.lower():
print('❌❌❌ 大写字母未自动变为小写字母')
# self.result_operate(answer, self.mine_answer()) # 下一步按钮后的答案页面 测试
self.click_voice()
self.next_btn_operate('true', self.fab_next_btn)
time.sleep(2)
index += 1
print('-'*30, '\n')
return index
@teststeps
def recite_word_spell_operate(self, stu_id, bank_count, recite_new_explain_words, only_apply_explains):
"""单词拼写 复习"""
print('===== 🌟🌟 单词默写 复习 🌟🌟 ===== \n')
for x in range(bank_count):
explain = self.word_explain() # 解释
print('解释：', explain.text)
explain_id = explain.get_attribute('contentDescription')
if explain_id in recite_new_explain_words:
print('❌❌❌ 此单词为新释义单词，不应出现单词拼写游戏')
if explain_id in only_apply_explains:
print('❌❌❌ 此单词为只有词汇运用单词， 不应出现在单词拼写中')
self.next_btn_judge('false', self.fab_commit_btn) # 下一题 按钮 状态判断
right_word = self.data.get_word_by_explain_id(stu_id, explain_id)
self.spell_right_word_operate(right_word)
self.next_btn_operate('true', self.fab_commit_btn)
print('我输入的：', right_word)
if not self.wait_check_play_voice_page():
print('❌❌❌ 点击提交按钮后未发现喇叭按钮')
self.next_btn_operate('true', self.fab_next_btn)
print('-'*30, '\n')
# @teststeps
# def dictation_pattern_mine(self, i, familiar_add, spell_word):
# """单词默写 我的单词"""
# if i == 0:
# print("\n单词拼写 - 默写模式(单词详情)\n")
# explain = self.word_explain() # 题目
# value = self.data.get_word_by_explain(explain)
# familiars = self.data.get_familiar_words() + familiar_add
# intersect_list = list(set(value).intersection(set(familiars))) # 取获取单词数组与标星单词数组的交集
# if i in range(0, 5):
# self.dictation_pattern_core(spell_word, word_type=1)
# if len(intersect_list) == 0:
# print('❌❌❌ Error-- 单词未被标熟却出现默写模式')
# else:
# FlashCard().tips_operate()
# for i in familiar_add:
# level = self.data.get_word_level(i)
# if level < 3:
# print("❌❌❌ Error--提交未成功，单词熟练度未更改")
@teststeps
def hint_ele_operate(self, value):
self.next_btn_judge('false', self.fab_commit_btn) # 下一题 按钮 判断加 点击操作
if self.wait_check_tv_word_or_random_page(): # 默写模式 - 字母未全部消除
print('❌❌❌ Error - 单词拼写 默写模式 - 字母未全部消除')
hint = self.hint_btn() # 提示按钮
if GetAttribute().get_enabled(hint) == 'true':
hint.click() # 点击 提示按钮
if GetAttribute().get_enabled(self.hint_btn()) != 'false':
print('❌❌❌ Error - 点击后提示按钮enabled属性错误')
if self.wait_check_tv_word_or_random_page(): # 出现首字母提示
first_word = self.spell_word().text[::2]
if first_word == value[0]:
print('点击提示出现首字母提示', first_word)
else:
print('点击提示出现首字母提示', first_word)
else:
print("❌❌❌ Error - 首字母提示未出现")
else:
print('❌❌❌ Error - 提示按钮enabled属性错误')
@teststeps
def result_operate(self, answer, mine):
"""下一步按钮后的答案页面"""
print('我的答案:', answer)
print('去除大小写结果:', mine)
if self.wait_check_right_answer_page():
correct = self.right_answer_word() # 正确答案
print('填写错误，正确答案:', correct)
if len(mine) <= len(correct): # 输入少于或等于单词字母数的字符
if mine.lower() != answer.lower(): # 展示的 我的答题结果 是否与我填入的一致
print('❌❌❌ Error - 字符数少于或等于时:', mine.lower(), answer.lower())
else: # 输入过多的字符
if correct + mine[len(correct):].lower() != correct + answer[len(correct):].lower():
# 展示的 我的答题结果 是否与我填入的一致
print('❌❌❌ Error - 字符输入过多时:', correct + mine[len(correct):].lower(), correct + answer[len(
correct):].lower())
else: # 回答正确
if mine.lower() != answer.lower(): # 展示的 我的答题结果 是否与我填入的一致
print('❌❌❌ Error - 展示的答题结果 与我填入的不一致:', mine.lower(), answer.lower())
else:
print('回答正确!')
print('-'*30, '\n')
@teststeps
def keyboard_operate(self, j, value):
"""点击键盘 具体操作"""
if j == 4:
self.key.games_keyboard('capslock') # 点击键盘 切换到 大写字母
self.key.games_keyboard(value.upper()) # 点击键盘对应 大写字母
self.key.games_keyboard('capslock') # 点击键盘 切换到 小写字母
else:
self.key.games_keyboard(value) # 点击键盘对应字母
@teststeps
def dictation_random_pattern_recite(self, stu_id, wrong_words):
"""错题再练 单词拼写 随机模式"""
for x in range(len(wrong_words)):
self.next_btn_judge('false', self.fab_commit_btn)
explain = self.word_explain()
print('解释：', explain.text)
explain_id = explain.get_attribute('contentDescription')
word = self.data.get_word_by_explain_id(stu_id, explain_id)
print("正确单词：", word)
tip_word = self.spell_word().text[1::2]
print('提示词：', tip_word)
right_word = [x for x in word if len(x) == len(tip_word)]
alphas = [right_word[0][x] for x in range(len(right_word[0])) if tip_word[x] == '_']
print(alphas)
for k in range(len(alphas)):
self.keyboard_operate(k, alphas[k]) # 点击键盘 具体操作
print('填充后单词为：', self.spell_word().text[1::2])
self.next_btn_operate('true', self.fab_commit_btn)
if self.wait_check_play_voice_page():
self.sound_icon().click()
else:
print('❌❌❌ 未发现声音按钮')
self.next_btn_operate('true', self.fab_next_btn) # 下一题 按钮 判断加 点击操作
time.sleep(2)
def __init__(self):
self.mysql = WordTestSql()
self.rebuild_handler = WordDataHandlePage()
class WordTestSqlHandler(BasePage):
def __init__(self):
self.mysql = WordTestSql()
self.rebuild_handler = WordDataHandlePage()
@teststep
def get_f_glt_3_count(self, stu_id):
"""获取单词F值>=3的个数"""
word_count = self.mysql.find_f_glt_3_count(stu_id)
return word_count[0][0] if word_count else 0
@teststep
def get_student_test_star_score(self, stu_id):
"""获取测试的星星积分"""
result = {}
star_score_data = self.mysql.find_student_start_score_data(stu_id)
for x in star_score_data:
if x[0] in list(result.keys()):
result['score'] = 0
else:
result[x[0]] = x[1]
return result
@teststep
def get_result_data(self, test_id):
"""获取结果页结果"""
result = self.mysql.find_test_result_data(test_id)
return result[0]
@teststep
def get_test_words(self, stu_id, get_type, word_count=0):
"""获取学生单词F值>=3的单词个数
:param word_count: 需要测试的单词数, 0 为该类型的全部单词
:param get_type: 测试类型 1：F>=3 单词 2：测试未通过单词 3：测试通过单词
:param stu_id 学生id
"""
if get_type == 1:
word_result = self.mysql.find_f_glt_3_words(stu_id)
elif get_type == 2:
word_result = self.mysql.find_test_fail_pass_words(stu_id)
else:
word_result = self.mysql.find_test_success_pass_words(stu_id)
test_list = word_result[:word_count] if word_count else word_result
word_info = {}
for x in test_list:
if str(x[0]) not in list(word_info.keys()):
word_info[str(x[0])] = list(
self.mysql.find_student_translation_by_word_id(
stu_id, x[0]))
else:
continue
return word_info
@teststep
def get_word_explain_list(self, explain_info):
"""获取测试单词对应解释列表"""
explain_list = [
self.rebuild_handler.get_explain_by_id(x[0]) for x in explain_info
]
reform_list = '；'.join(explain_list).split('；')
return reform_list
@teststep
def get_translation_count_by_word_id(self, test_id, word_ids):
"""获取解释个数根据单词id"""
result = self.mysql.find_test_translation_by_word_ids(
test_id, word_ids)
return len(result)
@teststep
def get_fvalue_by_word_explain_id(self, stu_id, word_id, explain_id):
"""根据单词、解释id定位学生已被单词的F值"""
result = self.mysql.find_student_word_fvalue_by_word_explain_id(
stu_id, word_id, explain_id)
return result[0][0] if result else -1
@teststep
def delete_student_test_data(self, stu_id):
"""删除学生单词测试相关数据"""
student_test_ids = self.mysql.find_student_test_id(stu_id)
if len(student_test_ids):
for x in student_test_ids:
self.mysql.delete_student_test_item_map(x[0])
self.mysql.delete_student_test(stu_id)
self.mysql.delete_student_test_record(stu_id)
self.mysql.delete_student_test_overview(stu_id)
self.mysql.delete_student_word_data(stu_id)