.gitignore

@@ -20,6 +20,7 @@
*.egg-info/
.installed.cfg
*.egg
download/

# Installer logs
pip-log.txt

 base/base_page.py

@@ -1,20 +1,272 @@
import importlib
import time

from selenium.common import StaleElementReferenceException, ElementClickInterceptedException
from selenium.webdriver.remote.webelement import WebElement
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.remote.webdriver import WebDriver

SimpleActions = ['clear()', 'send_keys()', 'click()', 'submit()', 'size', 'text', 'is_displayed()', 'get_attribute()']
complexActions = ['iframe()', 'select()', 'option()']

# 默认超时时间10秒
DEFAULT_TIMEOUT = 10
# 默认重试次数
DEFAULT_RETRY = 30


class BasePage:

    retry_number = 0

    # 初始化方法
    def __init__(self, driver):
    def __init__(self, driver: WebDriver):
        """构造方法，传入webdriver"""
        self.driver = driver

    # 元素定位
    def get_element(self, locator):
        return self.driver.find_element(*locator)
    # def _get_page_elem(self, elem):
    #     """获取定位元素的by，以及操作action"""
    #     for each in self.elements:
    #         if each['name'] == elem:
    #             self.loc = each['loc']
    #             if each['action'] is not None:
    #                 self.action = each['action']
    #             else:
    #                 self.action = None
    #             if 'optionsLoc' in each:
    #                 self.optionsLoc = each['optionsLoc']
    #             else:
    #                 self.optionsLoc = None
    #             if 'wait' in each:
    #                 self.wait = each['wait']
    #             else:
    #                 self.wait = None
    #
    # def oper_elem(self, elem, args=None):
    #     self._get_page_elem(elem)
    #     cmd = self._selenium_cmd('find_element', args)
    #     return eval(cmd)
    #
    # def oper_elems(self, elem, args=None):
    #     self._get_page_elem(elem)
    #     cmd = self._selenium_cmd('find_elements', args)
    #     return eval(cmd)
    #
    # def _selenium_cmd(self, find_type='find_element', args=None):
    #     """拼接selenium查找命令，查找单个元素时find为'find_element',多个元素时为'find_elements'"""
    #     cmd = 'self.driver.' + find_type + '(*self.loc)'
    #     if self.action:
    #         cmd = 'self.' + self.action
    #         if args:
    #             cmd = cmd[:-1] + 'args' + ')'
    #     return cmd
    #
    # def iframe(self):
    #     self.driver.switch_to.frame(self.driver.find_element(*self.loc))
    #
    # def click(self):
    #     if self.wait:
    #         wait = WebDriverWait(self.driver, self.wait, 0.5)
    #         wait.until(EC.presence_of_element_located(self.loc)).click()
    #     else:
    #         self.driver.find_element(*self.loc).click()
    #
    # # 使用js语句点击
    # def click_js(self):
    #     item = self.driver.find_element(*self.loc)
    #     self.driver.execute_script("arguments[0].click();", item)
    #
    # def send_keys(self, text):
    #     wait = WebDriverWait(self.driver, 10, 0.5)
    #     wait.until(EC.presence_of_element_located(self.loc)).send_keys(text)
    #
    # def text(self):
    #     wait = WebDriverWait(self.driver, 10, 0.5)
    #     return wait.until(EC.presence_of_element_located(self.loc)).text
    #
    def select(self, select_loc, options_loc, item):
        """
        选择传入的选项
        :param select_loc: 选择框定位
        :param options_loc: 选项定位
        :param item: 选项
        :return:
        """
        # 点击选择框对象
        self.click(select_loc, timeout=10)
        # 获取所有选项
        options = self.get_eles(options_loc, timeout=10)
        for option in options:
            if option.text == item:
                option.click()
                break
    #
    # def value_js(self):
    #     """
    #     使用js语句获取value值
    #     :return:
    #     """
    #     # 等待对象
    #     wait = WebDriverWait(self.driver, 10, 0.5)
    #     input_box = wait.until(EC.presence_of_element_located(self.loc))
    #     input_value = self.driver.execute_script("return arguments[0].value", input_box)
    #     return input_value
    #
    # def option(self, text):
    #     """
    #     点击传入的选项
    #     :param text:
    #     :return:
    #     """
    #     wait = WebDriverWait(self.driver, 10, 0.5)
    #     wait.until(EC.presence_of_all_elements_located(self.loc))
    #     options = self.driver.find_elements(*self.loc)
    #     for option in options:
    #         if option.text == text:
    #             option.click()

    # 多个元素定位
    def get_elements(self, locator):
        return self.driver.find_elements(*locator)
    # 元素定位

    def goto(self, url):
        """访问url"""
        self.driver.get(url)

    def get_ele(self, loc, timeout=None) -> WebElement:
        """
        获取元素
        :param loc: 元素定位
        :param timeout: 超时时间
        :return:
        """
        if timeout:
            return self.wait_visible(loc, timeout)
        else:
            return self.driver.find_element(*loc)

    def get_eles(self, loc, timeout=None):
        """
        获取多个元素
        :param loc: 元素定位
        :param timeout: 超时时间
        :return:
        """
        if timeout:
            return self.wait_visible(loc, timeout=timeout, find_type="elements")
        else:
            return self.driver.find_elements(*loc)

    def clear(self, loc, timeout=None):
        """
        清除文本框内容
        :param loc:
        :param timeout:
        :return:
        """
        ele = self.get_ele(loc, timeout=timeout)
        ele.clear()

    def fill(self, loc, text, timeout=None):
        """页面输入"""

        ele = self.get_ele(loc, timeout=timeout)
        # 先清除文本框内容
        ele.clear()
        # 填写内容
        ele.send_keys(text)

    def wait_visible(self, loc, timeout=DEFAULT_TIMEOUT, find_type="element") -> WebElement:
        """
        等待元素可见
        :param loc: 元素定位
        :param timeout: 等待时间
        :param find_type: 等待元素的类型
        :return:
        """
        wait = WebDriverWait(self.driver, timeout=timeout)
        element = None
        if find_type == "element":
            element = wait.until(EC.visibility_of_element_located(loc))
        elif find_type == "elements":
            element = wait.until(EC.visibility_of_all_elements_located(loc))
        return element

    def click(self, loc, timeout=None):
        """
        点击元素
        :param loc: 元素定位
        :param timeout: 超时时间
        :return:
        """
        try:
            if timeout:
                ele = self.wait_clickable(loc, timeout=timeout)
                ele.click()
            else:
                ele = self.driver.find_element(*loc)
                ele.click()
            self.retry_number = 0
        except (StaleElementReferenceException, ElementClickInterceptedException):
            if self.retry_number >= DEFAULT_RETRY:
                return
            time.sleep(1)
            self.retry_number += 1
            self.click(loc, timeout=timeout)

    def click_js(self, loc, timeout=None):
        """
        JavaScript点击元素
        :param loc:
        :param timeout:
        :return:
        """
        item = self.get_ele(loc, timeout=timeout)
        self.driver.execute_script("arguments[0].click();", item)

    def wait_clickable(self, loc, timeout=DEFAULT_TIMEOUT) -> WebElement:
        """
        等待元素可点击
        :param loc: 元素定位
        :param timeout: 超时时间
        :return:
        """
        wait = WebDriverWait(self.driver, timeout=timeout)
        element = wait.until(EC.element_to_be_clickable(loc))
        return element

    def equals(self, loc, text):
        """
        判断元素的value或者text是否与text相等
        :param loc:
        :param text:
        :return:
        """
        # 先获取value
        ele_value = self.get_ele(loc, timeout=10).get_attribute("value")
        # 如果为None则通过value_js获取value值
        if not ele_value:
            ele_value = self.get_value_js(loc, timeout=10)
        # 如果还为空则获取text
        if not ele_value:
            ele_value = self.get_ele(loc, timeout=10).text
        return ele_value == text

    def contains(self, loc, text):
        """
        判断元素的value或者text包含text
        :param loc:
        :param text:
        :return:
        """
        # 先获取value
        ele_value = self.get_ele(loc).get_attribute("value")
        # 如果为None则通过value_js获取value值
        if not ele_value:
            ele_value = self.get_value_js(loc)
        # 如果还为空则获取text
        if not ele_value:
            ele_value = self.get_ele(loc).text
        return text in ele_value

    # 多个元素定位
    def get_elements_wait(self, locator):
@@ -36,11 +288,6 @@
        wait.until(EC.presence_of_element_located(locator))
        return self.driver.find_element(*locator)

    # 使用js语句点击
    def click_js(self, *locator):
        item = self.get_element(*locator)
        self.driver.execute_script("arguments[0].click();", item)

    def click_js_wait(self, *locator):
        item = self.get_element_wait(*locator)
        self.driver.execute_script("arguments[0].click();", item)
@@ -53,36 +300,41 @@
        """
        self.driver.execute_script("arguments[0].click();", element)

    # 点击
    def click(self, locator):
        """
        点击元素
        :param locator: 元素定位
        :return:
        """
        self.get_element(locator).click()
    # # 点击
    # def click(self, locator):
    #     """
    #     点击元素
    #     :param locator: 元素定位
    #     :return:
    #     """
    #     self.get_element(locator).click()

    def click_wait(self, *locator):
        self.get_element_wait(*locator).click()

    # 输入
    def send_text(self, text, locator):
        """
        输入内容
        :param text: 内容
        :param locator: 元素定位
        :return:
        """
        self.get_element(locator).send_keys(text)
    # # 输入
    # def fill(self, text, locator):
    #     """
    #     输入内容
    #     :param text: 内容
    #     :param locator: 元素定位
    #     :return:
    #     """
    #     self.get_element(locator).send_keys(text)

    def send_text_wait(self, text, *locator):
        self.get_element_wait(*locator).send_keys(text)

    # JavaScript获取元素值
    def get_input_value_js(self, locator):
        input_box = self.get_element(locator)
        input_value = self.driver.execute_script("return arguments[0].value", input_box)
        return input_value
    def get_value_js(self, loc, timeout=None):
        """
        执行JavaScript获取value值
        :param timeout:
        :param loc:
        :return:
        """
        ele = self.get_ele(loc, timeout=timeout)
        value = self.driver.execute_script("return arguments[0].value", ele)
        return value

    def get_input_value_js_wait(self, *locator):
        input_box = self.get_element_wait(*locator)
@@ -97,11 +349,21 @@
        self.get_element_wait(*locator).clear()

    # 表单切换
    def switch_iframe(self, locator):
        self.driver.switch_to.frame(self.get_element(locator))
    def switch_iframe(self, loc):
        """
        切换表单
        :param loc: 表单定位
        :return:
        """
        # 获取到iframe元素
        iframe = self.get_ele(loc, timeout=10)
        self.driver.switch_to.frame(iframe)

    # 切换到上一层的iframe
    def switch_parent_iframe(self):
        """
        切换到上一层的iframe
        :return:
        """
        self.driver.switch_to.parent_frame()

    def switch_iframe_wait(self, locator):
@@ -150,7 +412,7 @@
        """截取当前窗口保存为图片"""
        return self.driver.get_screenshot_as_png()

    def open_new_table_to_url(self, url):
    def goto_new_table(self, url):
        """
        打开一个新的标签页，并跳转到指定的url
        :return:
@@ -171,3 +433,26 @@
        wait = WebDriverWait(self.driver, 10, 0.5)
        return wait.until(EC.visibility_of_any_elements_located(locator))

    def add_elements(self, ele):
        """
        在elements中新增元素
        :param ele:
        :return:
        """
        self.elements.append(ele)


def get_page_elements(page):
    """
    动态加载页面定义文件，获取文件中定义的元素列表elements
    :param page:
    :return:
    """
    elements = None
    if page:
        try:
            m = importlib.import_module(page)
            elements = m.elements
        except Exception as e:
            pass
    return elements

 comm/comm.py

New file
@@ -0,0 +1,17 @@
import os
import random
import string


def listdir(dir_path):
    file_names = []
    for filename in os.listdir(dir_path):
        if os.path.isfile(os.path.join(dir_path, filename)):
            if ".crdownload" not in filename:
                file_names.append(filename)
    return file_names


def generate_random_string(length):
    letters = string.ascii_letters + string.digits
    return ''.join(random.choice(letters) for _ in range(length))

 comm/read_data.py

New file
@@ -0,0 +1,36 @@
import codecs
import csv
from openpyxl import load_workbook


def read_csv(file_name):
    data_list = list()
    with codecs.open(file_name, encoding="utf-8") as f:
        for row in csv.DictReader(f, skipinitialspace=True):
            data_list.append(row)

    return data_list


def read_excel(file_name, sheet_name):
    # 打开Excel文件，加载workbook
    workbook = load_workbook(filename=file_name)
    # 根据名称获取worksheet
    worksheet = workbook.get_sheet_by_name(sheet_name)
    # 获取所有数据
    rows = worksheet.rows

    # 将第一行数据作为字典的键
    header = []
    for cell in next(rows):
        header.append(cell.value)

    # 从第二行起遍历每一行数据，并存储到字典中
    data_list = []
    for row in rows:
        data = {}
        for i, cell in enumerate(row):
            data[header[i]] = cell.value
        data_list.append(data)

    return data_list

 comm/write_data.py

New file
@@ -0,0 +1,18 @@
from openpyxl import load_workbook, Workbook


def write_excel(file_name, data):
    # 打开Excel文件，加载workbook
    flag = False
    try:
        workbook = load_workbook(filename=file_name)
    except FileNotFoundError:
        flag = True
        workbook = Workbook()
    # 根据名称获取worksheet
    worksheet = workbook.active

    if flag:
        worksheet.append(["账号", "充值数", "实际充值数", "充值前余额", "充值后余额"])
    worksheet.append(data)
    workbook.save(filename=file_name)

 data/MAQ_group_data.xlsx

Binary files differ

 data/question_data.json

New file
@@ -0,0 +1,596 @@
{
  "MAQ0001": {
    "title": "我不喜欢花时间检查小细节的准确性"
  },
  "MAQ0003": {
    "title": "我从不说谎，甚至连小谎都没有说过"
  },
  "MAQ0004": {
    "title": "当我做一个项目时，我会全力以赴，直到完成为止"
  },
  "MAQ0005": {
    "title": "我倾向于使用常规方法，而不是那些从未尝试过的方法"
  },
  "MAQ0006": {
    "title": "当我不得不去负责一个团队的时候，我会感觉战兢、恐惧"
  },
  "MAQ0007": {
    "title": "我有时因为各种干扰因素，未能按时完成工作任务"
  },
  "MAQ0009": {
    "title": "我能够控制自己的情绪状态，使其他人不太容易知道我内心的感受"
  },
  "MAQ0010": {
    "title": "我支持所在组织的价值观和规范，并了解其重要性"
  },
  "MAQ0011": {
    "title": "我不会因失败或挫折而泄气"
  },
  "MAQ0013": {
    "title": "我从来没有在街上乱扔垃圾"
  },
  "MAQ0014": {
    "title": "有时我发现让别人听从我的指示是件很困难的事"
  },
  "MAQ0015": {
    "title": "必要时，我能很容易地长时间完全专注于重要的工作项目"
  },
  "MAQ0019": {
    "title": "在项目遭受重大挫折之后，我并不是总能激发团队的斗志"
  },
  "MAQ0020": {
    "title": "我从未在背后说过朋友的坏话"
  },
  "MAQ0021": {
    "title": "我喜欢根据直觉来解决问题，而不是花较长时间进行系统的分析"
  },
  "MAQ0024": {
    "title": "政策和规定总的来说只是指导性意见，在方便时应当遵守，在不方便时可以灵活处理"
  },
  "MAQ0025": {
    "title": "面对工作环境的变化，我很乐意尝试新的工作方式"
  },
  "MAQ0026": {
    "title": "我喜欢搜寻和研究数据，看看数据能给出怎样的方向。"
  },
  "MAQ0027": {
    "title": "当我看到其他团队成员需要帮助时，我会调整我的工作日程，腾出时间来帮助他们"
  },
  "MAQ0028": {
    "title": "在开会时，我有时会被自己或他人的负面情绪所干扰"
  },
  "MAQ0029": {
    "title": "我经常是团队中第一个提出行动方案的"
  },
  "MAQ0030": {
    "title": "我主动参与或领导别人不愿意承担的工作项目"
  },
  "MAQ0034": {
    "title": "我经常向我的同事和下属强调，我们所做的所有决策都必须符合组织的价值观和规范"
  },
  "MAQ0035": {
    "title": "有时别人的负面情绪会影响我自己的情绪"
  },
  "MAQ0036": {
    "title": "我经常创造性地把别人的不同想法结合起来，并找到有效的问题解决办法"
  },
  "MAQ0038": {
    "title": "我曾经利用过其他人"
  },
  "MAQ0039": {
    "title": "我喜欢分析复杂的概念并发现它们之间的逻辑联系"
  },
  "MAQ0040": {
    "title": "我很享受仔细检查小细节的过程"
  },
  "MAQ0041": {
    "title": "自律对我来说很容易做到"
  },
  "MAQ0042": {
    "title": "开始做任何项目前，我都会首先梳理任务的轻重缓急和截止日期"
  },
  "MAQ0044": {
    "title": "即使在很忙的时候，如果我知道我是某项工作的最佳人选，我也会自愿去承担这些额外的工作"
  },
  "MAQ0045": {
    "title": "工作上遭遇失败或挫折时，我会开始怀疑自己"
  },
  "MAQ0046": {
    "title": "我没有仔细校对自己的工作或报告的习惯"
  },
  "MAQ0047": {
    "title": "我有时做事需要别人提醒才能按时完成"
  },
  "MAQ0048": {
    "title": "我很乐意担任领导的角色"
  },
  "MAQ0049": {
    "title": "当我的上司不在的时候，我不喜欢自己做工作上的决策"
  },
  "MAQ0051": {
    "title": "在工作中，我没有为实现目标而努力并获得成就和认可的动力"
  },
  "MAQ0053": {
    "title": "如果能选择，我更喜欢事先计划好的例行活动，而不喜欢去适应各种不确定性"
  },
  "MAQ0055": {
    "title": "当手头有其它工作要做时，我不太愿意帮助团队成员"
  },
  "MAQ0058": {
    "title": "有时候我怀疑自己是否能胜任当前工作"
  },
  "MAQ0059": {
    "title": "当我在工作中受到别人的质疑或挑战时，我总能够避免用充满敌意的方式去回应"
  },
  "MAQ0060": {
    "title": "在被别人质疑或挑战时，我总是抑制自己的第一反应，以避免情绪化的反应"
  },
  "MAQ0061": {
    "title": "我不愿意接受独立决策所带来的风险"
  },
  "MAQ0062": {
    "title": "我很愿意为需要帮助的人提供帮助"
  },
  "MAQ0064": {
    "title": "相比于主动确定自己的发展需求，我更依赖于我的组织来确定我需要发展哪些能力和技能"
  },
  "MAQ0065": {
    "title": "在报告各类数字和财务数据时，我力求准确"
  },
  "MAQ0067": {
    "title": "我经常会提出多种方案来解决某个问题"
  },
  "MAQ0069": {
    "title": "在确定工作的优先等级时，我通常会将我不喜欢的工作安排到最后"
  },
  "MAQ0070": {
    "title": "我经常发现我不得不搁置工作项目"
  },
  "MAQ0071": {
    "title": "在开始一个项目前，我会列出所有需要完成的任务"
  },
  "MAQ0072": {
    "title": "我觉得很难和那些质疑我观点的团队成员相处"
  },
  "MAQ0073": {
    "title": "我经常通过外界的反馈和自我反省来深入思考如何提升自己的技能和竞争力"
  },
  "MAQ0074": {
    "title": "一旦团队做出了决定，即使我不赞同，我也会跟着团队的决定走"
  },
  "MAQ0076": {
    "title": "在做出困难的决定时，我并不总是能够遵循组织的价值观和规范"
  },
  "MAQ0077": {
    "title": "当我在工作中受到批评时，我容易生气，失去冷静"
  },
  "MAQ0078": {
    "title": "我发现花很多时间来检查数据，分析问题的根源是件很枯燥的事"
  },
  "MAQ0079": {
    "title": "当我情绪激动时，就无法清晰地思考"
  },
  "MAQ0080": {
    "title": "总有人会被上级任命去领导一个项目，而我要做的是等着并听从他们的安排"
  },
  "MAQ0081": {
    "title": "有时候我很难集中精力去完成自己不喜欢的任务"
  },
  "MAQ0082": {
    "title": "由于意料之外的困难，有几次我决定放弃某些项目"
  },
  "MAQ0084": {
    "title": "我常常是团队中第一个发现工作中的改进机会的人"
  },
  "MAQ0085": {
    "title": "我定期了解所在团队的最新状况，以确保我们能够实现团队目标"
  },
  "MAQ0086": {
    "title": "我发现很难适应计划的改变，因为总是会有相当大的干扰"
  },
  "MAQ0087": {
    "title": "在社交聚会的场合招待好刚认识的人对我来说是件容易的事"
  },
  "MAQ0088": {
    "title": "我偶尔会让别人为我的错误受到责备"
  },
  "MAQ0089": {
    "title": "我并不能完全掌控自己的命运"
  },
  "MAQ0090": {
    "title": "我觉得激励一个新的而且成员背景多样化的团队是挺困难的事"
  },
  "MAQ0091": {
    "title": "工作上的压力从来都不会影响我的睡眠质量"
  },
  "MAQ0092": {
    "title": "我倾向于避免参加过多的社交或人际交往活动"
  },
  "MAQ0094": {
    "title": "我并不总是知道如何与刚认识的人攀谈"
  },
  "MAQ0095": {
    "title": "我喜欢对员工进行新任务的培训，并向他们解释为什么这些培训对团队成就和工作绩效很重要"
  },
  "MAQ0097": {
    "title": "别人经常能够在团队工作的成果中发现我所没有发现的错误"
  },
  "MAQ0098": {
    "title": "我倾向于花费比其他人更多的时间来探索数据，以寻找潜在的问题原因，从而产生有用的见解"
  },
  "MAQ0099": {
    "title": "如果我的老板不在身边，我愿意自己做重要的决定"
  },
  "MAQ0100": {
    "title": "我不喜欢需要开发新的解决方案的工作"
  },
  "MAQ0101": {
    "title": "只有在和老板充分商讨了自己的想法后，我才会启动某个新举措"
  },
  "MAQ0103": {
    "title": "我会努力在截止日期前完成任务，兑现工作中的承诺，如有必要可以牺牲个人时间"
  },
  "MAQ0104": {
    "title": "有时我会受情绪支配而无法控制自己的应对方式"
  },
  "MAQ0106": {
    "title": "我经常通过参加研讨会、网络研讨会和阅读来更新自己的专业和行业知识"
  },
  "MAQ0107": {
    "title": "我对于第一印象不好的人不太有耐心和礼貌"
  },
  "MAQ0110": {
    "title": "人们经常来找我讨论他们的问题或苦恼"
  },
  "MAQ0111": {
    "title": "我经常帮助别人更好地理解和处理他们自己的负面情绪"
  },
  "MAQ0112": {
    "title": "我的同事们能够很容易看出我的情绪状态"
  },
  "MAQ0113": {
    "title": "我并不是总有时间检查我的工作，并相信不检查也问题不大"
  },
  "MAQ0115": {
    "title": "当新的工作流程或技术被引入时，我通常是最早接受并采用它的人"
  },
  "MAQ0117": {
    "title": "即使面临高压的工作，我也会保持乐观的期望"
  },
  "MAQ0118": {
    "title": "有时我会很难理解自己的情绪反应"
  },
  "MAQ0119": {
    "title": "在工作中，我经常设立有挑战性的目标，然后努力实现目标"
  },
  "MAQ0120": {
    "title": "我非常抵触那些不得不去参加的社交活动，认为那会很心累"
  },
  "MAQ0124": {
    "title": "我总是知道自己的情绪感受以及原因"
  },
  "MAQ0126": {
    "title": "我更喜欢不紧不慢，从容不迫的工作节奏，而不喜欢经常需要同时完成多个任务的工作节奏"
  },
  "MAQ0127": {
    "title": "当我意识到有人在评估我的表现时，我会变得比别人更焦虑"
  },
  "MAQ0129": {
    "title": "当我不得不按照任务的轻重缓急的次序来工作时，我会有一种受限制的感觉"
  },
  "MAQ0130": {
    "title": "我有时会感到过度劳累，但是我始终相信自己有足够的精力来完成所有工作任务"
  },
  "MAQ0131": {
    "title": "与主动承担相比，我更喜欢被上级要求去承担某项任务或加入或领导一个项目团队"
  },
  "MAQ0132": {
    "title": "人们遇到困难时通常会到我这里来寻求情感支持"
  },
  "MAQ0133": {
    "title": "我并不总是能够诚实地面对自己"
  },
  "MAQ0134": {
    "title": "我比较擅长安慰沮丧或生气的同事，并让其冷静下来"
  },
  "MAQ0135": {
    "title": "我认真倾听，以此来了解别人的感受和需求"
  },
  "MAQ0136": {
    "title": "我有时为了达成目标会对政策和规定作灵活的处理"
  },
  "MAQ0138": {
    "title": "我更喜欢可预测的、按部就班的日常工作"
  },
  "MAQ0140": {
    "title": "我喜欢那种上司对我充分授权，让我能自主决策的工作环境"
  },
  "MAQ0141": {
    "title": "我比自己认识的大多数人都更加坚持是非原则"
  },
  "MAQ0142": {
    "title": "我对参与公益事业(志愿活动)不太感兴趣"
  },
  "MAQ0143": {
    "title": "我不喜欢分析假想会发生的情境或理论模型"
  },
  "MAQ0144": {
    "title": "初次与人见面时，我比较沉默寡言，常常等待对方主动开口交谈"
  },
  "MAQ0145": {
    "title": "我有时会做出一些让我事后感到后悔的决定"
  },
  "MAQ0146": {
    "title": "有时候，我很难理解别人的情绪反应"
  },
  "MAQ0147": {
    "title": "我更喜欢遵循已经完善了的工作流程，而不是考虑新方法"
  },
  "MAQ0149": {
    "title": "在人际交往中，我常常做不到换位思考"
  },
  "MAQ0150": {
    "title": "我觉得好像其他人比我更能投入更多精力去完成工作任务"
  },
  "MAQ0151": {
    "title": "我喜欢整理和发表具有令人信服的理由的演讲，以此来说服其他人"
  },
  "MAQ0152": {
    "title": "我不喜欢始终快节奏地工作"
  },
  "MAQ0156": {
    "title": "当我未能实现工作中的一个重要目标时，我很快就会恢复过来，重新专注于如何达成目标"
  },
  "MAQ0157": {
    "title": "我不愿意改变我既有的工作方式"
  },
  "MAQ0158": {
    "title": "我喜欢不断变化，而不是稳定"
  },
  "MAQ0159": {
    "title": "当我在工作中得到负面反馈时，我也从不怀疑自己工作的能力"
  },
  "MAQ0160": {
    "title": "我一直有强烈的意愿去领导和指挥一群人"
  },
  "MAQ0161": {
    "title": "面对一个障碍或困难，我会不停地努力去克服它，直到成功"
  },
  "MAQ0162": {
    "title": "在工作项目的计划阶段，我总是确认该项目的利益攸关方并确保他们对该项目的承诺"
  },
  "MAQ0163": {
    "title": "有时我会受到情绪的影响，做出一些让自己后悔的决定"
  },
  "MAQ0164": {
    "title": "我总是知道是什么影响了我的情绪"
  },
  "MAQ0165": {
    "title": "当别人向我抱怨他们在工作上或生活中碰到的问题时，我常常无法感同身受"
  },
  "MAQ0166": {
    "title": "对于我来说，说服别人是件容易的事"
  },
  "MAQ0167": {
    "title": "有时我发现工作上的担忧或问题会对我的个人生活产生负面影响"
  },
  "MAQ0168": {
    "title": "我曾经在没有真的生病的情况下，向公司或学校请过病假"
  },
  "MAQ0169": {
    "title": "我有时会按照自己的兴趣而不是任务的轻重缓急来决定自己的工作顺序"
  },
  "MAQ0170": {
    "title": "工作让我充满活力， 以至于我发现自己常常沉浸在工作中，过了睡觉的点都不知道"
  },
  "MAQ0171": {
    "title": "我觉得变化是非常令人兴奋的，尽管对其他人来说可能很难"
  },
  "MAQ0172": {
    "title": "我擅长改变别人的观点和看法"
  },
  "MAQ0173": {
    "title": "我并不是总能做到言行一致"
  },
  "MAQ0174": {
    "title": "有时我发现改变别人的观点和看法很难"
  },
  "MAQ0175": {
    "title": "当遇到自己不喜欢或比较困难的任务时，我通常会拖延一段时间再开始"
  },
  "MAQ0176": {
    "title": "我喜欢与其他团队成员进行协作，以避免重复或无效的工作"
  },
  "MAQ0178": {
    "title": "我总是按时完成工作任务"
  },
  "MAQ0179": {
    "title": "我第一次见到别人时就可以很容易地读懂他们，但是不管第一印象如何，我都会保持礼貌和周到"
  },
  "MAQ0180": {
    "title": "我经常是第一个自愿领导或加入项目团队的人"
  },
  "MAQ0181": {
    "title": "当手头正在做的项目出现意外的困难时，我发现有时我会停下来，转而做其它项目"
  },
  "MAQ0182": {
    "title": "我会定期向我的团队成员提供反馈，以帮助他们个人发展并实现职业目标"
  },
  "MAQ0183": {
    "title": "我喜欢立即开始处理困难的任务，而不是拖延"
  },
  "MAQ0184": {
    "title": "在开会时我总是专注于主题，与他人互动，并专心地倾听他人的发言"
  },
  "MAQ0185": {
    "title": "我不喜欢为自己或团队设立挑战性的目标，并不得不花额外的时间去达成这些目标"
  },
  "MAQ0187": {
    "title": "相比与他人合作，我更愿意自己一人完成工作任务"
  },
  "MAQ0190": {
    "title": "每次开始新工作或新项目时，我通常会充满信心"
  },
  "MAQ0191": {
    "title": "我发现主动与刚认识的人攀谈是容易的事"
  },
  "MAQ0192": {
    "title": "我愿意自己做决定并接受相应的后果"
  },
  "MAQ0193": {
    "title": "我偶尔因为必须完成其他重要的事情而没有按时完成工作任务"
  },
  "MAQ0194": {
    "title": "只要愿意，我可以轻松地与任何人交朋友"
  },
  "MAQ0195": {
    "title": "我喜欢对复杂方案的利弊进行全面的分析"
  },
  "MAQ0197": {
    "title": "我不会尝试自己去提出新想法，而是希望把此类事情让给对此感兴趣的人去做"
  },
  "MAQ0199": {
    "title": "我总是能很快想出说服别人的最佳方法"
  },
  "MAQ0200": {
    "title": "我不会让挫折或失望对我的工作表现产生负面影响"
  },
  "MAQ0201": {
    "title": "当我在工作中遭遇挫折或失败时，我需要较长时间才能完全恢复自信"
  },
  "MAQ0202": {
    "title": "对于我不喜欢的人，我无法总是保持礼貌和恭敬"
  },
  "MAQ0203": {
    "title": "大多数人最终都会同意我的观点"
  },
  "MAQ0204": {
    "title": "如果我认为刚认识的人对我不礼貌，也不尊重我，那我也不会对他们有礼貌或尊重"
  },
  "MAQ0205": {
    "title": "在进行某个项目时，我会定期监控项目重要节点的完成进度，并跟进负责各个具体模块的团队成员"
  },
  "MAQ0206": {
    "title": "在和他人谈判的时候，我偶尔会觉得缺乏自信"
  },
  "MAQ0207": {
    "title": "有时我很难说服别人接受我的建议"
  },
  "MAQ0208": {
    "title": "即使不情愿，我也会非常仔细地检查哪怕最小的细节"
  },
  "MAQ0209": {
    "title": "他人认为我能力一般"
  },
  "MAQ0210": {
    "title": "我不喜欢培训团队中的新员工以确保他们做事方式是正确的"
  },
  "MAQ0211": {
    "title": "如果需要的话，我总能找到更多的时间来完成工作"
  },
  "MAQ0212": {
    "title": "与我的同事相比，我不太喜欢收集和分析数据。"
  },
  "MAQ0213": {
    "title": "我确保兑现所有工作上的承诺，因为这对我而言是一个严肃、神圣的原则"
  },
  "MAQ0214": {
    "title": "同事们经常来请教我应该如何和别人沟通敏感话题"
  },
  "MAQ0216": {
    "title": "尽管有时可能不方便，但我始终遵守政策和规定"
  },
  "MAQ0218": {
    "title": "对于那些我认为比较困难或者成功可能性不高的项目，我经常拖延时间，而不立即启动"
  },
  "MAQ0219": {
    "title": "我从未因工作上的失败而灰心"
  },
  "MAQ0220": {
    "title": "当我的工作负荷增加时，有时我会感到失去耐心、心烦意乱"
  },
  "MAQ0221": {
    "title": "我始终确保恪守我所有的职业承诺并信守诺言"
  },
  "MAQ0223": {
    "title": "我更喜欢那些可以充分发挥创造性的工作"
  },
  "MAQ0224": {
    "title": "有时候工作中的失望和失败会使我好几天都无法集中注意力"
  },
  "MAQ0225": {
    "title": "我不喜欢不断地说服别人接受我的建议"
  },
  "MAQ0226": {
    "title": "我在同事中有能圆融地和难相处的人打交道的名声"
  },
  "MAQ0227": {
    "title": "我经常处理很多不同的项目、想法或者讨论，我发现这让人精神振奋"
  },
  "MAQ0228": {
    "title": "当事情没有按照我的预想发展时，我会变得沮丧"
  },
  "MAQ0229": {
    "title": "我喜欢参加商业社交活动"
  },
  "MAQ0230": {
    "title": "有时我对交谈对象的文化背景、习俗、和禁忌不够敏感"
  },
  "MAQ0231": {
    "title": "在社交互动中，我通常对别人的需求不够敏感"
  },
  "MAQ0232": {
    "title": "我对他人的第一印象通常是准确的"
  },
  "MAQ0233": {
    "title": "我通常能在工作中控制好自己的情绪"
  },
  "MAQ0234": {
    "title": "当我在某个工作项目中碰到困难时，我有时会中止该项目，转而去做其它项目"
  },
  "MAQ0235": {
    "title": "在我的生活和职业中，我总是知道自己想要什么"
  },
  "MAQ0236": {
    "title": "和新认识的人，我从不会感到没话可说"
  },
  "MAQ0237": {
    "title": "即使团队中的大部分成员跟我的意见/看法相左，我通常也不愿意放弃自己的意见/看法，跟大伙儿达成一致。"
  },
  "MAQ0240": {
    "title": "如果我和其他人合作一项任务，我会等着他们来找我协调工作"
  },
  "MAQ0241": {
    "title": "我小时候曾经拿过本不属于自己的东西"
  },
  "MAQ0242": {
    "title": "在得到老板的明确指示前，我通常不会采取行动"
  },
  "MAQ0243": {
    "title": "我常常在下属的工作报告中发现错误"
  },
  "MAQ0244": {
    "title": "我从未违反过交通规则"
  },
  "MAQ0245": {
    "title": "我在团队中经常是勇于挑战团队工作设想和方向的人"
  },
  "MAQ0247": {
    "title": "在工作项目开始之前，我会和团队成员先开会协调，做好项目计划"
  },
  "MAQ0248": {
    "title": "我不怎么花时间与下属讨论他们的职业发展目标或进展"
  },
  "MAQ0249": {
    "title": "我从不浏览不好的网站"
  },
  "MAQ0250": {
    "title": "我有时会闲聊别人的家长里短"
  },
  "MAQ0251": {
    "title": "本题请选“同意”"
  },
  "MAQ0252": {
    "title": "本题请选“非常不同意”"
  }
}

 data/test_data.json

@@ -1,4 +1,602 @@
{
  "question": {
    "MAQ": {
      "MAQ0001": {
        "title": "我不喜欢花时间检查小细节的准确性"
      },
      "MAQ0003": {
        "title": "我从不说谎，甚至连小谎都没有说过"
      },
      "MAQ0004": {
        "title": "当我做一个项目时，我会全力以赴，直到完成为止"
      },
      "MAQ0005": {
        "title": "我倾向于使用常规方法，而不是那些从未尝试过的方法"
      },
      "MAQ0006": {
        "title": "当我不得不去负责一个团队的时候，我会感觉战兢、恐惧"
      },
      "MAQ0007": {
        "title": "我有时因为各种干扰因素，未能按时完成工作任务"
      },
      "MAQ0009": {
        "title": "我能够控制自己的情绪状态，使其他人不太容易知道我内心的感受"
      },
      "MAQ0010": {
        "title": "我支持所在组织的价值观和规范，并了解其重要性"
      },
      "MAQ0011": {
        "title": "我不会因失败或挫折而泄气"
      },
      "MAQ0013": {
        "title": "我从来没有在街上乱扔垃圾"
      },
      "MAQ0014": {
        "title": "有时我发现让别人听从我的指示是件很困难的事"
      },
      "MAQ0015": {
        "title": "必要时，我能很容易地长时间完全专注于重要的工作项目"
      },
      "MAQ0019": {
        "title": "在项目遭受重大挫折之后，我并不是总能激发团队的斗志"
      },
      "MAQ0020": {
        "title": "我从未在背后说过朋友的坏话"
      },
      "MAQ0021": {
        "title": "我喜欢根据直觉来解决问题，而不是花较长时间进行系统的分析"
      },
      "MAQ0024": {
        "title": "政策和规定总的来说只是指导性意见，在方便时应当遵守，在不方便时可以灵活处理"
      },
      "MAQ0025": {
        "title": "面对工作环境的变化，我很乐意尝试新的工作方式"
      },
      "MAQ0026": {
        "title": "我喜欢搜寻和研究数据，看看数据能给出怎样的方向。"
      },
      "MAQ0027": {
        "title": "当我看到其他团队成员需要帮助时，我会调整我的工作日程，腾出时间来帮助他们"
      },
      "MAQ0028": {
        "title": "在开会时，我有时会被自己或他人的负面情绪所干扰"
      },
      "MAQ0029": {
        "title": "我经常是团队中第一个提出行动方案的"
      },
      "MAQ0030": {
        "title": "我主动参与或领导别人不愿意承担的工作项目"
      },
      "MAQ0034": {
        "title": "我经常向我的同事和下属强调，我们所做的所有决策都必须符合组织的价值观和规范"
      },
      "MAQ0035": {
        "title": "有时别人的负面情绪会影响我自己的情绪"
      },
      "MAQ0036": {
        "title": "我经常创造性地把别人的不同想法结合起来，并找到有效的问题解决办法"
      },
      "MAQ0038": {
        "title": "我曾经利用过其他人"
      },
      "MAQ0039": {
        "title": "我喜欢分析复杂的概念并发现它们之间的逻辑联系"
      },
      "MAQ0040": {
        "title": "我很享受仔细检查小细节的过程"
      },
      "MAQ0041": {
        "title": "自律对我来说很容易做到"
      },
      "MAQ0042": {
        "title": "开始做任何项目前，我都会首先梳理任务的轻重缓急和截止日期"
      },
      "MAQ0044": {
        "title": "即使在很忙的时候，如果我知道我是某项工作的最佳人选，我也会自愿去承担这些额外的工作"
      },
      "MAQ0045": {
        "title": "工作上遭遇失败或挫折时，我会开始怀疑自己"
      },
      "MAQ0046": {
        "title": "我没有仔细校对自己的工作或报告的习惯"
      },
      "MAQ0047": {
        "title": "我有时做事需要别人提醒才能按时完成"
      },
      "MAQ0048": {
        "title": "我很乐意担任领导的角色"
      },
      "MAQ0049": {
        "title": "当我的上司不在的时候，我不喜欢自己做工作上的决策"
      },
      "MAQ0051": {
        "title": "在工作中，我没有为实现目标而努力并获得成就和认可的动力"
      },
      "MAQ0053": {
        "title": "如果能选择，我更喜欢事先计划好的例行活动，而不喜欢去适应各种不确定性"
      },
      "MAQ0055": {
        "title": "当手头有其它工作要做时，我不太愿意帮助团队成员"
      },
      "MAQ0058": {
        "title": "有时候我怀疑自己是否能胜任当前工作"
      },
      "MAQ0059": {
        "title": "当我在工作中受到别人的质疑或挑战时，我总能够避免用充满敌意的方式去回应"
      },
      "MAQ0060": {
        "title": "在被别人质疑或挑战时，我总是抑制自己的第一反应，以避免情绪化的反应"
      },
      "MAQ0061": {
        "title": "我不愿意接受独立决策所带来的风险"
      },
      "MAQ0062": {
        "title": "我很愿意为需要帮助的人提供帮助"
      },
      "MAQ0064": {
        "title": "相比于主动确定自己的发展需求，我更依赖于我的组织来确定我需要发展哪些能力和技能"
      },
      "MAQ0065": {
        "title": "在报告各类数字和财务数据时，我力求准确"
      },
      "MAQ0067": {
        "title": "我经常会提出多种方案来解决某个问题"
      },
      "MAQ0069": {
        "title": "在确定工作的优先等级时，我通常会将我不喜欢的工作安排到最后"
      },
      "MAQ0070": {
        "title": "我经常发现我不得不搁置工作项目"
      },
      "MAQ0071": {
        "title": "在开始一个项目前，我会列出所有需要完成的任务"
      },
      "MAQ0072": {
        "title": "我觉得很难和那些质疑我观点的团队成员相处"
      },
      "MAQ0073": {
        "title": "我经常通过外界的反馈和自我反省来深入思考如何提升自己的技能和竞争力"
      },
      "MAQ0074": {
        "title": "一旦团队做出了决定，即使我不赞同，我也会跟着团队的决定走"
      },
      "MAQ0076": {
        "title": "在做出困难的决定时，我并不总是能够遵循组织的价值观和规范"
      },
      "MAQ0077": {
        "title": "当我在工作中受到批评时，我容易生气，失去冷静"
      },
      "MAQ0078": {
        "title": "我发现花很多时间来检查数据，分析问题的根源是件很枯燥的事"
      },
      "MAQ0079": {
        "title": "当我情绪激动时，就无法清晰地思考"
      },
      "MAQ0080": {
        "title": "总有人会被上级任命去领导一个项目，而我要做的是等着并听从他们的安排"
      },
      "MAQ0081": {
        "title": "有时候我很难集中精力去完成自己不喜欢的任务"
      },
      "MAQ0082": {
        "title": "由于意料之外的困难，有几次我决定放弃某些项目"
      },
      "MAQ0084": {
        "title": "我常常是团队中第一个发现工作中的改进机会的人"
      },
      "MAQ0085": {
        "title": "我定期了解所在团队的最新状况，以确保我们能够实现团队目标"
      },
      "MAQ0086": {
        "title": "我发现很难适应计划的改变，因为总是会有相当大的干扰"
      },
      "MAQ0087": {
        "title": "在社交聚会的场合招待好刚认识的人对我来说是件容易的事"
      },
      "MAQ0088": {
        "title": "我偶尔会让别人为我的错误受到责备"
      },
      "MAQ0089": {
        "title": "我并不能完全掌控自己的命运"
      },
      "MAQ0090": {
        "title": "我觉得激励一个新的而且成员背景多样化的团队是挺困难的事"
      },
      "MAQ0091": {
        "title": "工作上的压力从来都不会影响我的睡眠质量"
      },
      "MAQ0092": {
        "title": "我倾向于避免参加过多的社交或人际交往活动"
      },
      "MAQ0094": {
        "title": "我并不总是知道如何与刚认识的人攀谈"
      },
      "MAQ0095": {
        "title": "我喜欢对员工进行新任务的培训，并向他们解释为什么这些培训对团队成就和工作绩效很重要"
      },
      "MAQ0097": {
        "title": "别人经常能够在团队工作的成果中发现我所没有发现的错误"
      },
      "MAQ0098": {
        "title": "我倾向于花费比其他人更多的时间来探索数据，以寻找潜在的问题原因，从而产生有用的见解"
      },
      "MAQ0099": {
        "title": "如果我的老板不在身边，我愿意自己做重要的决定"
      },
      "MAQ0100": {
        "title": "我不喜欢需要开发新的解决方案的工作"
      },
      "MAQ0101": {
        "title": "只有在和老板充分商讨了自己的想法后，我才会启动某个新举措"
      },
      "MAQ0103": {
        "title": "我会努力在截止日期前完成任务，兑现工作中的承诺，如有必要可以牺牲个人时间"
      },
      "MAQ0104": {
        "title": "有时我会受情绪支配而无法控制自己的应对方式"
      },
      "MAQ0106": {
        "title": "我经常通过参加研讨会、网络研讨会和阅读来更新自己的专业和行业知识"
      },
      "MAQ0107": {
        "title": "我对于第一印象不好的人不太有耐心和礼貌"
      },
      "MAQ0110": {
        "title": "人们经常来找我讨论他们的问题或苦恼"
      },
      "MAQ0111": {
        "title": "我经常帮助别人更好地理解和处理他们自己的负面情绪"
      },
      "MAQ0112": {
        "title": "我的同事们能够很容易看出我的情绪状态"
      },
      "MAQ0113": {
        "title": "我并不是总有时间检查我的工作，并相信不检查也问题不大"
      },
      "MAQ0115": {
        "title": "当新的工作流程或技术被引入时，我通常是最早接受并采用它的人"
      },
      "MAQ0117": {
        "title": "即使面临高压的工作，我也会保持乐观的期望"
      },
      "MAQ0118": {
        "title": "有时我会很难理解自己的情绪反应"
      },
      "MAQ0119": {
        "title": "在工作中，我经常设立有挑战性的目标，然后努力实现目标"
      },
      "MAQ0120": {
        "title": "我非常抵触那些不得不去参加的社交活动，认为那会很心累"
      },
      "MAQ0124": {
        "title": "我总是知道自己的情绪感受以及原因"
      },
      "MAQ0126": {
        "title": "我更喜欢不紧不慢，从容不迫的工作节奏，而不喜欢经常需要同时完成多个任务的工作节奏"
      },
      "MAQ0127": {
        "title": "当我意识到有人在评估我的表现时，我会变得比别人更焦虑"
      },
      "MAQ0129": {
        "title": "当我不得不按照任务的轻重缓急的次序来工作时，我会有一种受限制的感觉"
      },
      "MAQ0130": {
        "title": "我有时会感到过度劳累，但是我始终相信自己有足够的精力来完成所有工作任务"
      },
      "MAQ0131": {
        "title": "与主动承担相比，我更喜欢被上级要求去承担某项任务或加入或领导一个项目团队"
      },
      "MAQ0132": {
        "title": "人们遇到困难时通常会到我这里来寻求情感支持"
      },
      "MAQ0133": {
        "title": "我并不总是能够诚实地面对自己"
      },
      "MAQ0134": {
        "title": "我比较擅长安慰沮丧或生气的同事，并让其冷静下来"
      },
      "MAQ0135": {
        "title": "我认真倾听，以此来了解别人的感受和需求"
      },
      "MAQ0136": {
        "title": "我有时为了达成目标会对政策和规定作灵活的处理"
      },
      "MAQ0138": {
        "title": "我更喜欢可预测的、按部就班的日常工作"
      },
      "MAQ0140": {
        "title": "我喜欢那种上司对我充分授权，让我能自主决策的工作环境"
      },
      "MAQ0141": {
        "title": "我比自己认识的大多数人都更加坚持是非原则"
      },
      "MAQ0142": {
        "title": "我对参与公益事业(志愿活动)不太感兴趣"
      },
      "MAQ0143": {
        "title": "我不喜欢分析假想会发生的情境或理论模型"
      },
      "MAQ0144": {
        "title": "初次与人见面时，我比较沉默寡言，常常等待对方主动开口交谈"
      },
      "MAQ0145": {
        "title": "我有时会做出一些让我事后感到后悔的决定"
      },
      "MAQ0146": {
        "title": "有时候，我很难理解别人的情绪反应"
      },
      "MAQ0147": {
        "title": "我更喜欢遵循已经完善了的工作流程，而不是考虑新方法"
      },
      "MAQ0149": {
        "title": "在人际交往中，我常常做不到换位思考"
      },
      "MAQ0150": {
        "title": "我觉得好像其他人比我更能投入更多精力去完成工作任务"
      },
      "MAQ0151": {
        "title": "我喜欢整理和发表具有令人信服的理由的演讲，以此来说服其他人"
      },
      "MAQ0152": {
        "title": "我不喜欢始终快节奏地工作"
      },
      "MAQ0156": {
        "title": "当我未能实现工作中的一个重要目标时，我很快就会恢复过来，重新专注于如何达成目标"
      },
      "MAQ0157": {
        "title": "我不愿意改变我既有的工作方式"
      },
      "MAQ0158": {
        "title": "我喜欢不断变化，而不是稳定"
      },
      "MAQ0159": {
        "title": "当我在工作中得到负面反馈时，我也从不怀疑自己工作的能力"
      },
      "MAQ0160": {
        "title": "我一直有强烈的意愿去领导和指挥一群人"
      },
      "MAQ0161": {
        "title": "面对一个障碍或困难，我会不停地努力去克服它，直到成功"
      },
      "MAQ0162": {
        "title": "在工作项目的计划阶段，我总是确认该项目的利益攸关方并确保他们对该项目的承诺"
      },
      "MAQ0163": {
        "title": "有时我会受到情绪的影响，做出一些让自己后悔的决定"
      },
      "MAQ0164": {
        "title": "我总是知道是什么影响了我的情绪"
      },
      "MAQ0165": {
        "title": "当别人向我抱怨他们在工作上或生活中碰到的问题时，我常常无法感同身受"
      },
      "MAQ0166": {
        "title": "对于我来说，说服别人是件容易的事"
      },
      "MAQ0167": {
        "title": "有时我发现工作上的担忧或问题会对我的个人生活产生负面影响"
      },
      "MAQ0168": {
        "title": "我曾经在没有真的生病的情况下，向公司或学校请过病假"
      },
      "MAQ0169": {
        "title": "我有时会按照自己的兴趣而不是任务的轻重缓急来决定自己的工作顺序"
      },
      "MAQ0170": {
        "title": "工作让我充满活力， 以至于我发现自己常常沉浸在工作中，过了睡觉的点都不知道"
      },
      "MAQ0171": {
        "title": "我觉得变化是非常令人兴奋的，尽管对其他人来说可能很难"
      },
      "MAQ0172": {
        "title": "我擅长改变别人的观点和看法"
      },
      "MAQ0173": {
        "title": "我并不是总能做到言行一致"
      },
      "MAQ0174": {
        "title": "有时我发现改变别人的观点和看法很难"
      },
      "MAQ0175": {
        "title": "当遇到自己不喜欢或比较困难的任务时，我通常会拖延一段时间再开始"
      },
      "MAQ0176": {
        "title": "我喜欢与其他团队成员进行协作，以避免重复或无效的工作"
      },
      "MAQ0178": {
        "title": "我总是按时完成工作任务"
      },
      "MAQ0179": {
        "title": "我第一次见到别人时就可以很容易地读懂他们，但是不管第一印象如何，我都会保持礼貌和周到"
      },
      "MAQ0180": {
        "title": "我经常是第一个自愿领导或加入项目团队的人"
      },
      "MAQ0181": {
        "title": "当手头正在做的项目出现意外的困难时，我发现有时我会停下来，转而做其它项目"
      },
      "MAQ0182": {
        "title": "我会定期向我的团队成员提供反馈，以帮助他们个人发展并实现职业目标"
      },
      "MAQ0183": {
        "title": "我喜欢立即开始处理困难的任务，而不是拖延"
      },
      "MAQ0184": {
        "title": "在开会时我总是专注于主题，与他人互动，并专心地倾听他人的发言"
      },
      "MAQ0185": {
        "title": "我不喜欢为自己或团队设立挑战性的目标，并不得不花额外的时间去达成这些目标"
      },
      "MAQ0187": {
        "title": "相比与他人合作，我更愿意自己一人完成工作任务"
      },
      "MAQ0190": {
        "title": "每次开始新工作或新项目时，我通常会充满信心"
      },
      "MAQ0191": {
        "title": "我发现主动与刚认识的人攀谈是容易的事"
      },
      "MAQ0192": {
        "title": "我愿意自己做决定并接受相应的后果"
      },
      "MAQ0193": {
        "title": "我偶尔因为必须完成其他重要的事情而没有按时完成工作任务"
      },
      "MAQ0194": {
        "title": "只要愿意，我可以轻松地与任何人交朋友"
      },
      "MAQ0195": {
        "title": "我喜欢对复杂方案的利弊进行全面的分析"
      },
      "MAQ0197": {
        "title": "我不会尝试自己去提出新想法，而是希望把此类事情让给对此感兴趣的人去做"
      },
      "MAQ0199": {
        "title": "我总是能很快想出说服别人的最佳方法"
      },
      "MAQ0200": {
        "title": "我不会让挫折或失望对我的工作表现产生负面影响"
      },
      "MAQ0201": {
        "title": "当我在工作中遭遇挫折或失败时，我需要较长时间才能完全恢复自信"
      },
      "MAQ0202": {
        "title": "对于我不喜欢的人，我无法总是保持礼貌和恭敬"
      },
      "MAQ0203": {
        "title": "大多数人最终都会同意我的观点"
      },
      "MAQ0204": {
        "title": "如果我认为刚认识的人对我不礼貌，也不尊重我，那我也不会对他们有礼貌或尊重"
      },
      "MAQ0205": {
        "title": "在进行某个项目时，我会定期监控项目重要节点的完成进度，并跟进负责各个具体模块的团队成员"
      },
      "MAQ0206": {
        "title": "在和他人谈判的时候，我偶尔会觉得缺乏自信"
      },
      "MAQ0207": {
        "title": "有时我很难说服别人接受我的建议"
      },
      "MAQ0208": {
        "title": "即使不情愿，我也会非常仔细地检查哪怕最小的细节"
      },
      "MAQ0209": {
        "title": "他人认为我能力一般"
      },
      "MAQ0210": {
        "title": "我不喜欢培训团队中的新员工以确保他们做事方式是正确的"
      },
      "MAQ0211": {
        "title": "如果需要的话，我总能找到更多的时间来完成工作"
      },
      "MAQ0212": {
        "title": "与我的同事相比，我不太喜欢收集和分析数据。"
      },
      "MAQ0213": {
        "title": "我确保兑现所有工作上的承诺，因为这对我而言是一个严肃、神圣的原则"
      },
      "MAQ0214": {
        "title": "同事们经常来请教我应该如何和别人沟通敏感话题"
      },
      "MAQ0216": {
        "title": "尽管有时可能不方便，但我始终遵守政策和规定"
      },
      "MAQ0218": {
        "title": "对于那些我认为比较困难或者成功可能性不高的项目，我经常拖延时间，而不立即启动"
      },
      "MAQ0219": {
        "title": "我从未因工作上的失败而灰心"
      },
      "MAQ0220": {
        "title": "当我的工作负荷增加时，有时我会感到失去耐心、心烦意乱"
      },
      "MAQ0221": {
        "title": "我始终确保恪守我所有的职业承诺并信守诺言"
      },
      "MAQ0223": {
        "title": "我更喜欢那些可以充分发挥创造性的工作"
      },
      "MAQ0224": {
        "title": "有时候工作中的失望和失败会使我好几天都无法集中注意力"
      },
      "MAQ0225": {
        "title": "我不喜欢不断地说服别人接受我的建议"
      },
      "MAQ0226": {
        "title": "我在同事中有能圆融地和难相处的人打交道的名声"
      },
      "MAQ0227": {
        "title": "我经常处理很多不同的项目、想法或者讨论，我发现这让人精神振奋"
      },
      "MAQ0228": {
        "title": "当事情没有按照我的预想发展时，我会变得沮丧"
      },
      "MAQ0229": {
        "title": "我喜欢参加商业社交活动"
      },
      "MAQ0230": {
        "title": "有时我对交谈对象的文化背景、习俗、和禁忌不够敏感"
      },
      "MAQ0231": {
        "title": "在社交互动中，我通常对别人的需求不够敏感"
      },
      "MAQ0232": {
        "title": "我对他人的第一印象通常是准确的"
      },
      "MAQ0233": {
        "title": "我通常能在工作中控制好自己的情绪"
      },
      "MAQ0234": {
        "title": "当我在某个工作项目中碰到困难时，我有时会中止该项目，转而去做其它项目"
      },
      "MAQ0235": {
        "title": "在我的生活和职业中，我总是知道自己想要什么"
      },
      "MAQ0236": {
        "title": "和新认识的人，我从不会感到没话可说"
      },
      "MAQ0237": {
        "title": "即使团队中的大部分成员跟我的意见/看法相左，我通常也不愿意放弃自己的意见/看法，跟大伙儿达成一致。"
      },
      "MAQ0240": {
        "title": "如果我和其他人合作一项任务，我会等着他们来找我协调工作"
      },
      "MAQ0241": {
        "title": "我小时候曾经拿过本不属于自己的东西"
      },
      "MAQ0242": {
        "title": "在得到老板的明确指示前，我通常不会采取行动"
      },
      "MAQ0243": {
        "title": "我常常在下属的工作报告中发现错误"
      },
      "MAQ0244": {
        "title": "我从未违反过交通规则"
      },
      "MAQ0245": {
        "title": "我在团队中经常是勇于挑战团队工作设想和方向的人"
      },
      "MAQ0247": {
        "title": "在工作项目开始之前，我会和团队成员先开会协调，做好项目计划"
      },
      "MAQ0248": {
        "title": "我不怎么花时间与下属讨论他们的职业发展目标或进展"
      },
      "MAQ0249": {
        "title": "我从不浏览不好的网站"
      },
      "MAQ0250": {
        "title": "我有时会闲聊别人的家长里短"
      },
      "MAQ0251": {
        "title": "本题请选“同意”"
      },
      "MAQ0252": {
        "title": "本题请选“非常不同意”"
      }
    }
  },
  "login": {
    "url": "http://161.117.57.194/login?lang=zh_CN",
    "username": "admin",
@@ -113,5 +711,717 @@
      "status": "未在寻找实习/工作",
      "workExperience": "无"
    }
  },
  "testPackageList": {
    "question": {
      "MAQ": {
      "MAQ0001": {
        "title": "我不喜欢花时间检查小细节的准确性"
      },
      "MAQ0003": {
        "title": "我从不说谎，甚至连小谎都没有说过"
      },
      "MAQ0004": {
        "title": "当我做一个项目时，我会全力以赴，直到完成为止"
      },
      "MAQ0005": {
        "title": "我倾向于使用常规方法，而不是那些从未尝试过的方法"
      },
      "MAQ0006": {
        "title": "当我不得不去负责一个团队的时候，我会感觉战兢、恐惧"
      },
      "MAQ0007": {
        "title": "我有时因为各种干扰因素，未能按时完成工作任务"
      },
      "MAQ0009": {
        "title": "我能够控制自己的情绪状态，使其他人不太容易知道我内心的感受"
      },
      "MAQ0010": {
        "title": "我支持所在组织的价值观和规范，并了解其重要性"
      },
      "MAQ0011": {
        "title": "我不会因失败或挫折而泄气"
      },
      "MAQ0013": {
        "title": "我从来没有在街上乱扔垃圾"
      },
      "MAQ0014": {
        "title": "有时我发现让别人听从我的指示是件很困难的事"
      },
      "MAQ0015": {
        "title": "必要时，我能很容易地长时间完全专注于重要的工作项目"
      },
      "MAQ0019": {
        "title": "在项目遭受重大挫折之后，我并不是总能激发团队的斗志"
      },
      "MAQ0020": {
        "title": "我从未在背后说过朋友的坏话"
      },
      "MAQ0021": {
        "title": "我喜欢根据直觉来解决问题，而不是花较长时间进行系统的分析"
      },
      "MAQ0024": {
        "title": "政策和规定总的来说只是指导性意见，在方便时应当遵守，在不方便时可以灵活处理"
      },
      "MAQ0025": {
        "title": "面对工作环境的变化，我很乐意尝试新的工作方式"
      },
      "MAQ0026": {
        "title": "我喜欢搜寻和研究数据，看看数据能给出怎样的方向。"
      },
      "MAQ0027": {
        "title": "当我看到其他团队成员需要帮助时，我会调整我的工作日程，腾出时间来帮助他们"
      },
      "MAQ0028": {
        "title": "在开会时，我有时会被自己或他人的负面情绪所干扰"
      },
      "MAQ0029": {
        "title": "我经常是团队中第一个提出行动方案的"
      },
      "MAQ0030": {
        "title": "我主动参与或领导别人不愿意承担的工作项目"
      },
      "MAQ0034": {
        "title": "我经常向我的同事和下属强调，我们所做的所有决策都必须符合组织的价值观和规范"
      },
      "MAQ0035": {
        "title": "有时别人的负面情绪会影响我自己的情绪"
      },
      "MAQ0036": {
        "title": "我经常创造性地把别人的不同想法结合起来，并找到有效的问题解决办法"
      },
      "MAQ0038": {
        "title": "我曾经利用过其他人"
      },
      "MAQ0039": {
        "title": "我喜欢分析复杂的概念并发现它们之间的逻辑联系"
      },
      "MAQ0040": {
        "title": "我很享受仔细检查小细节的过程"
      },
      "MAQ0041": {
        "title": "自律对我来说很容易做到"
      },
      "MAQ0042": {
        "title": "开始做任何项目前，我都会首先梳理任务的轻重缓急和截止日期"
      },
      "MAQ0044": {
        "title": "即使在很忙的时候，如果我知道我是某项工作的最佳人选，我也会自愿去承担这些额外的工作"
      },
      "MAQ0045": {
        "title": "工作上遭遇失败或挫折时，我会开始怀疑自己"
      },
      "MAQ0046": {
        "title": "我没有仔细校对自己的工作或报告的习惯"
      },
      "MAQ0047": {
        "title": "我有时做事需要别人提醒才能按时完成"
      },
      "MAQ0048": {
        "title": "我很乐意担任领导的角色"
      },
      "MAQ0049": {
        "title": "当我的上司不在的时候，我不喜欢自己做工作上的决策"
      },
      "MAQ0051": {
        "title": "在工作中，我没有为实现目标而努力并获得成就和认可的动力"
      },
      "MAQ0053": {
        "title": "如果能选择，我更喜欢事先计划好的例行活动，而不喜欢去适应各种不确定性"
      },
      "MAQ0055": {
        "title": "当手头有其它工作要做时，我不太愿意帮助团队成员"
      },
      "MAQ0058": {
        "title": "有时候我怀疑自己是否能胜任当前工作"
      },
      "MAQ0059": {
        "title": "当我在工作中受到别人的质疑或挑战时，我总能够避免用充满敌意的方式去回应"
      },
      "MAQ0060": {
        "title": "在被别人质疑或挑战时，我总是抑制自己的第一反应，以避免情绪化的反应"
      },
      "MAQ0061": {
        "title": "我不愿意接受独立决策所带来的风险"
      },
      "MAQ0062": {
        "title": "我很愿意为需要帮助的人提供帮助"
      },
      "MAQ0064": {
        "title": "相比于主动确定自己的发展需求，我更依赖于我的组织来确定我需要发展哪些能力和技能"
      },
      "MAQ0065": {
        "title": "在报告各类数字和财务数据时，我力求准确"
      },
      "MAQ0067": {
        "title": "我经常会提出多种方案来解决某个问题"
      },
      "MAQ0069": {
        "title": "在确定工作的优先等级时，我通常会将我不喜欢的工作安排到最后"
      },
      "MAQ0070": {
        "title": "我经常发现我不得不搁置工作项目"
      },
      "MAQ0071": {
        "title": "在开始一个项目前，我会列出所有需要完成的任务"
      },
      "MAQ0072": {
        "title": "我觉得很难和那些质疑我观点的团队成员相处"
      },
      "MAQ0073": {
        "title": "我经常通过外界的反馈和自我反省来深入思考如何提升自己的技能和竞争力"
      },
      "MAQ0074": {
        "title": "一旦团队做出了决定，即使我不赞同，我也会跟着团队的决定走"
      },
      "MAQ0076": {
        "title": "在做出困难的决定时，我并不总是能够遵循组织的价值观和规范"
      },
      "MAQ0077": {
        "title": "当我在工作中受到批评时，我容易生气，失去冷静"
      },
      "MAQ0078": {
        "title": "我发现花很多时间来检查数据，分析问题的根源是件很枯燥的事"
      },
      "MAQ0079": {
        "title": "当我情绪激动时，就无法清晰地思考"
      },
      "MAQ0080": {
        "title": "总有人会被上级任命去领导一个项目，而我要做的是等着并听从他们的安排"
      },
      "MAQ0081": {
        "title": "有时候我很难集中精力去完成自己不喜欢的任务"
      },
      "MAQ0082": {
        "title": "由于意料之外的困难，有几次我决定放弃某些项目"
      },
      "MAQ0084": {
        "title": "我常常是团队中第一个发现工作中的改进机会的人"
      },
      "MAQ0085": {
        "title": "我定期了解所在团队的最新状况，以确保我们能够实现团队目标"
      },
      "MAQ0086": {
        "title": "我发现很难适应计划的改变，因为总是会有相当大的干扰"
      },
      "MAQ0087": {
        "title": "在社交聚会的场合招待好刚认识的人对我来说是件容易的事"
      },
      "MAQ0088": {
        "title": "我偶尔会让别人为我的错误受到责备"
      },
      "MAQ0089": {
        "title": "我并不能完全掌控自己的命运"
      },
      "MAQ0090": {
        "title": "我觉得激励一个新的而且成员背景多样化的团队是挺困难的事"
      },
      "MAQ0091": {
        "title": "工作上的压力从来都不会影响我的睡眠质量"
      },
      "MAQ0092": {
        "title": "我倾向于避免参加过多的社交或人际交往活动"
      },
      "MAQ0094": {
        "title": "我并不总是知道如何与刚认识的人攀谈"
      },
      "MAQ0095": {
        "title": "我喜欢对员工进行新任务的培训，并向他们解释为什么这些培训对团队成就和工作绩效很重要"
      },
      "MAQ0097": {
        "title": "别人经常能够在团队工作的成果中发现我所没有发现的错误"
      },
      "MAQ0098": {
        "title": "我倾向于花费比其他人更多的时间来探索数据，以寻找潜在的问题原因，从而产生有用的见解"
      },
      "MAQ0099": {
        "title": "如果我的老板不在身边，我愿意自己做重要的决定"
      },
      "MAQ0100": {
        "title": "我不喜欢需要开发新的解决方案的工作"
      },
      "MAQ0101": {
        "title": "只有在和老板充分商讨了自己的想法后，我才会启动某个新举措"
      },
      "MAQ0103": {
        "title": "我会努力在截止日期前完成任务，兑现工作中的承诺，如有必要可以牺牲个人时间"
      },
      "MAQ0104": {
        "title": "有时我会受情绪支配而无法控制自己的应对方式"
      },
      "MAQ0106": {
        "title": "我经常通过参加研讨会、网络研讨会和阅读来更新自己的专业和行业知识"
      },
      "MAQ0107": {
        "title": "我对于第一印象不好的人不太有耐心和礼貌"
      },
      "MAQ0110": {
        "title": "人们经常来找我讨论他们的问题或苦恼"
      },
      "MAQ0111": {
        "title": "我经常帮助别人更好地理解和处理他们自己的负面情绪"
      },
      "MAQ0112": {
        "title": "我的同事们能够很容易看出我的情绪状态"
      },
      "MAQ0113": {
        "title": "我并不是总有时间检查我的工作，并相信不检查也问题不大"
      },
      "MAQ0115": {
        "title": "当新的工作流程或技术被引入时，我通常是最早接受并采用它的人"
      },
      "MAQ0117": {
        "title": "即使面临高压的工作，我也会保持乐观的期望"
      },
      "MAQ0118": {
        "title": "有时我会很难理解自己的情绪反应"
      },
      "MAQ0119": {
        "title": "在工作中，我经常设立有挑战性的目标，然后努力实现目标"
      },
      "MAQ0120": {
        "title": "我非常抵触那些不得不去参加的社交活动，认为那会很心累"
      },
      "MAQ0124": {
        "title": "我总是知道自己的情绪感受以及原因"
      },
      "MAQ0126": {
        "title": "我更喜欢不紧不慢，从容不迫的工作节奏，而不喜欢经常需要同时完成多个任务的工作节奏"
      },
      "MAQ0127": {
        "title": "当我意识到有人在评估我的表现时，我会变得比别人更焦虑"
      },
      "MAQ0129": {
        "title": "当我不得不按照任务的轻重缓急的次序来工作时，我会有一种受限制的感觉"
      },
      "MAQ0130": {
        "title": "我有时会感到过度劳累，但是我始终相信自己有足够的精力来完成所有工作任务"
      },
      "MAQ0131": {
        "title": "与主动承担相比，我更喜欢被上级要求去承担某项任务或加入或领导一个项目团队"
      },
      "MAQ0132": {
        "title": "人们遇到困难时通常会到我这里来寻求情感支持"
      },
      "MAQ0133": {
        "title": "我并不总是能够诚实地面对自己"
      },
      "MAQ0134": {
        "title": "我比较擅长安慰沮丧或生气的同事，并让其冷静下来"
      },
      "MAQ0135": {
        "title": "我认真倾听，以此来了解别人的感受和需求"
      },
      "MAQ0136": {
        "title": "我有时为了达成目标会对政策和规定作灵活的处理"
      },
      "MAQ0138": {
        "title": "我更喜欢可预测的、按部就班的日常工作"
      },
      "MAQ0140": {
        "title": "我喜欢那种上司对我充分授权，让我能自主决策的工作环境"
      },
      "MAQ0141": {
        "title": "我比自己认识的大多数人都更加坚持是非原则"
      },
      "MAQ0142": {
        "title": "我对参与公益事业(志愿活动)不太感兴趣"
      },
      "MAQ0143": {
        "title": "我不喜欢分析假想会发生的情境或理论模型"
      },
      "MAQ0144": {
        "title": "初次与人见面时，我比较沉默寡言，常常等待对方主动开口交谈"
      },
      "MAQ0145": {
        "title": "我有时会做出一些让我事后感到后悔的决定"
      },
      "MAQ0146": {
        "title": "有时候，我很难理解别人的情绪反应"
      },
      "MAQ0147": {
        "title": "我更喜欢遵循已经完善了的工作流程，而不是考虑新方法"
      },
      "MAQ0149": {
        "title": "在人际交往中，我常常做不到换位思考"
      },
      "MAQ0150": {
        "title": "我觉得好像其他人比我更能投入更多精力去完成工作任务"
      },
      "MAQ0151": {
        "title": "我喜欢整理和发表具有令人信服的理由的演讲，以此来说服其他人"
      },
      "MAQ0152": {
        "title": "我不喜欢始终快节奏地工作"
      },
      "MAQ0156": {
        "title": "当我未能实现工作中的一个重要目标时，我很快就会恢复过来，重新专注于如何达成目标"
      },
      "MAQ0157": {
        "title": "我不愿意改变我既有的工作方式"
      },
      "MAQ0158": {
        "title": "我喜欢不断变化，而不是稳定"
      },
      "MAQ0159": {
        "title": "当我在工作中得到负面反馈时，我也从不怀疑自己工作的能力"
      },
      "MAQ0160": {
        "title": "我一直有强烈的意愿去领导和指挥一群人"
      },
      "MAQ0161": {
        "title": "面对一个障碍或困难，我会不停地努力去克服它，直到成功"
      },
      "MAQ0162": {
        "title": "在工作项目的计划阶段，我总是确认该项目的利益攸关方并确保他们对该项目的承诺"
      },
      "MAQ0163": {
        "title": "有时我会受到情绪的影响，做出一些让自己后悔的决定"
      },
      "MAQ0164": {
        "title": "我总是知道是什么影响了我的情绪"
      },
      "MAQ0165": {
        "title": "当别人向我抱怨他们在工作上或生活中碰到的问题时，我常常无法感同身受"
      },
      "MAQ0166": {
        "title": "对于我来说，说服别人是件容易的事"
      },
      "MAQ0167": {
        "title": "有时我发现工作上的担忧或问题会对我的个人生活产生负面影响"
      },
      "MAQ0168": {
        "title": "我曾经在没有真的生病的情况下，向公司或学校请过病假"
      },
      "MAQ0169": {
        "title": "我有时会按照自己的兴趣而不是任务的轻重缓急来决定自己的工作顺序"
      },
      "MAQ0170": {
        "title": "工作让我充满活力， 以至于我发现自己常常沉浸在工作中，过了睡觉的点都不知道"
      },
      "MAQ0171": {
        "title": "我觉得变化是非常令人兴奋的，尽管对其他人来说可能很难"
      },
      "MAQ0172": {
        "title": "我擅长改变别人的观点和看法"
      },
      "MAQ0173": {
        "title": "我并不是总能做到言行一致"
      },
      "MAQ0174": {
        "title": "有时我发现改变别人的观点和看法很难"
      },
      "MAQ0175": {
        "title": "当遇到自己不喜欢或比较困难的任务时，我通常会拖延一段时间再开始"
      },
      "MAQ0176": {
        "title": "我喜欢与其他团队成员进行协作，以避免重复或无效的工作"
      },
      "MAQ0178": {
        "title": "我总是按时完成工作任务"
      },
      "MAQ0179": {
        "title": "我第一次见到别人时就可以很容易地读懂他们，但是不管第一印象如何，我都会保持礼貌和周到"
      },
      "MAQ0180": {
        "title": "我经常是第一个自愿领导或加入项目团队的人"
      },
      "MAQ0181": {
        "title": "当手头正在做的项目出现意外的困难时，我发现有时我会停下来，转而做其它项目"
      },
      "MAQ0182": {
        "title": "我会定期向我的团队成员提供反馈，以帮助他们个人发展并实现职业目标"
      },
      "MAQ0183": {
        "title": "我喜欢立即开始处理困难的任务，而不是拖延"
      },
      "MAQ0184": {
        "title": "在开会时我总是专注于主题，与他人互动，并专心地倾听他人的发言"
      },
      "MAQ0185": {
        "title": "我不喜欢为自己或团队设立挑战性的目标，并不得不花额外的时间去达成这些目标"
      },
      "MAQ0187": {
        "title": "相比与他人合作，我更愿意自己一人完成工作任务"
      },
      "MAQ0190": {
        "title": "每次开始新工作或新项目时，我通常会充满信心"
      },
      "MAQ0191": {
        "title": "我发现主动与刚认识的人攀谈是容易的事"
      },
      "MAQ0192": {
        "title": "我愿意自己做决定并接受相应的后果"
      },
      "MAQ0193": {
        "title": "我偶尔因为必须完成其他重要的事情而没有按时完成工作任务"
      },
      "MAQ0194": {
        "title": "只要愿意，我可以轻松地与任何人交朋友"
      },
      "MAQ0195": {
        "title": "我喜欢对复杂方案的利弊进行全面的分析"
      },
      "MAQ0197": {
        "title": "我不会尝试自己去提出新想法，而是希望把此类事情让给对此感兴趣的人去做"
      },
      "MAQ0199": {
        "title": "我总是能很快想出说服别人的最佳方法"
      },
      "MAQ0200": {
        "title": "我不会让挫折或失望对我的工作表现产生负面影响"
      },
      "MAQ0201": {
        "title": "当我在工作中遭遇挫折或失败时，我需要较长时间才能完全恢复自信"
      },
      "MAQ0202": {
        "title": "对于我不喜欢的人，我无法总是保持礼貌和恭敬"
      },
      "MAQ0203": {
        "title": "大多数人最终都会同意我的观点"
      },
      "MAQ0204": {
        "title": "如果我认为刚认识的人对我不礼貌，也不尊重我，那我也不会对他们有礼貌或尊重"
      },
      "MAQ0205": {
        "title": "在进行某个项目时，我会定期监控项目重要节点的完成进度，并跟进负责各个具体模块的团队成员"
      },
      "MAQ0206": {
        "title": "在和他人谈判的时候，我偶尔会觉得缺乏自信"
      },
      "MAQ0207": {
        "title": "有时我很难说服别人接受我的建议"
      },
      "MAQ0208": {
        "title": "即使不情愿，我也会非常仔细地检查哪怕最小的细节"
      },
      "MAQ0209": {
        "title": "他人认为我能力一般"
      },
      "MAQ0210": {
        "title": "我不喜欢培训团队中的新员工以确保他们做事方式是正确的"
      },
      "MAQ0211": {
        "title": "如果需要的话，我总能找到更多的时间来完成工作"
      },
      "MAQ0212": {
        "title": "与我的同事相比，我不太喜欢收集和分析数据。"
      },
      "MAQ0213": {
        "title": "我确保兑现所有工作上的承诺，因为这对我而言是一个严肃、神圣的原则"
      },
      "MAQ0214": {
        "title": "同事们经常来请教我应该如何和别人沟通敏感话题"
      },
      "MAQ0216": {
        "title": "尽管有时可能不方便，但我始终遵守政策和规定"
      },
      "MAQ0218": {
        "title": "对于那些我认为比较困难或者成功可能性不高的项目，我经常拖延时间，而不立即启动"
      },
      "MAQ0219": {
        "title": "我从未因工作上的失败而灰心"
      },
      "MAQ0220": {
        "title": "当我的工作负荷增加时，有时我会感到失去耐心、心烦意乱"
      },
      "MAQ0221": {
        "title": "我始终确保恪守我所有的职业承诺并信守诺言"
      },
      "MAQ0223": {
        "title": "我更喜欢那些可以充分发挥创造性的工作"
      },
      "MAQ0224": {
        "title": "有时候工作中的失望和失败会使我好几天都无法集中注意力"
      },
      "MAQ0225": {
        "title": "我不喜欢不断地说服别人接受我的建议"
      },
      "MAQ0226": {
        "title": "我在同事中有能圆融地和难相处的人打交道的名声"
      },
      "MAQ0227": {
        "title": "我经常处理很多不同的项目、想法或者讨论，我发现这让人精神振奋"
      },
      "MAQ0228": {
        "title": "当事情没有按照我的预想发展时，我会变得沮丧"
      },
      "MAQ0229": {
        "title": "我喜欢参加商业社交活动"
      },
      "MAQ0230": {
        "title": "有时我对交谈对象的文化背景、习俗、和禁忌不够敏感"
      },
      "MAQ0231": {
        "title": "在社交互动中，我通常对别人的需求不够敏感"
      },
      "MAQ0232": {
        "title": "我对他人的第一印象通常是准确的"
      },
      "MAQ0233": {
        "title": "我通常能在工作中控制好自己的情绪"
      },
      "MAQ0234": {
        "title": "当我在某个工作项目中碰到困难时，我有时会中止该项目，转而去做其它项目"
      },
      "MAQ0235": {
        "title": "在我的生活和职业中，我总是知道自己想要什么"
      },
      "MAQ0236": {
        "title": "和新认识的人，我从不会感到没话可说"
      },
      "MAQ0237": {
        "title": "即使团队中的大部分成员跟我的意见/看法相左，我通常也不愿意放弃自己的意见/看法，跟大伙儿达成一致。"
      },
      "MAQ0240": {
        "title": "如果我和其他人合作一项任务，我会等着他们来找我协调工作"
      },
      "MAQ0241": {
        "title": "我小时候曾经拿过本不属于自己的东西"
      },
      "MAQ0242": {
        "title": "在得到老板的明确指示前，我通常不会采取行动"
      },
      "MAQ0243": {
        "title": "我常常在下属的工作报告中发现错误"
      },
      "MAQ0244": {
        "title": "我从未违反过交通规则"
      },
      "MAQ0245": {
        "title": "我在团队中经常是勇于挑战团队工作设想和方向的人"
      },
      "MAQ0247": {
        "title": "在工作项目开始之前，我会和团队成员先开会协调，做好项目计划"
      },
      "MAQ0248": {
        "title": "我不怎么花时间与下属讨论他们的职业发展目标或进展"
      },
      "MAQ0249": {
        "title": "我从不浏览不好的网站"
      },
      "MAQ0250": {
        "title": "我有时会闲聊别人的家长里短"
      },
      "MAQ0251": {
        "title": "本题请选“同意”"
      },
      "MAQ0252": {
        "title": "本题请选“非常不同意”"
      }
    }
    },
    "menu": "测试包管理/测试包列表",
    "hint": "这是修改后的事中提示语",
    "name": "高明",
    "email": "2077506045@qq.com",
    "add": {
      "company": "TAI测试",
      "type": "人格测试包",
      "area": "美国",
      "product": "MAQV2",
      "hrEmail": "4c08@qq.com",
      "invalid": "2024-01-01 00:00:00",
      "memberLang": "English",
      "hrReportLang": "English",
      "reportTemplate": "MAQV2-Complete-English",
      "memberReportLang": "English"
    },
    "edit": {
      "company": "TAI测试修改",
      "area": "中国",
      "type": "人格测试包",
      "product": "MAQV2",
      "hrEmail": "2077506045@qq.com",
      "invalid": "2025-01-01 09:00:00",
      "memberLang": "中文",
      "hrReportLang": "中文",
      "reportTemplate": "MAQV2-Complete-Chinese",
      "memberReportLang": "中文"
    },
    "info": {
      "position":"职员",
      "dept": "人事部"
    },
    "downloadWaitTime": 20
  },
  "memberDetail": {
    "add": {
      "name": "白瑞辰",
      "dept": "人事部",
      "email": "sadfasldf@qq.com",
      "phone": "15930084180",
      "remark": "这是一个备注信息"
    },
    "edit": {
      "name": "高明",
      "dept": "事业部",
      "email": "2077506045@qq.com",
      "phone": "15011947664",
      "remark": "这是一个修改后的备注信息"
    },
    "downloadWaitTime": 20
  },
  "productAccredit": {
    "menu": "测试包管理/产品包授权",
    "username": "ZCH2023",
    "product": "CAQ",
    "password": "123456",
    "code": "ots",
    "add": {
      "company": "TAI产品包授权测试",
      "area": "中国",
      "type": "智力测验包",
      "product": "CAQ",
      "hrEmail": "2077506045@qq.com",
      "invalid": "2025-01-01 09:00:00",
      "memberLang": "中文",
      "hrReportLang": "中文",
      "reportTemplate": "CAQ-CAQ-Chinese",
      "memberReportLang": "中文"
    }

  },
  "groupReport": {
  }
}
}









































 elements/export_test_data_elements.py

New file
@@ -0,0 +1,30 @@
from selenium.webdriver.common.by import By


class ExportTestDataElements:
    # 查看评测报告tab_name
    tab_name_report = "查看评测报告"

    # this-iframe
    this_iframe = (By.XPATH, "//iframe[contains(@src,'/exam/report/reportView/evaluationReport')]")

    # 产品包select
    product_select = (By.XPATH, "//select[@name='productId']")
    # 产品包option
    product_option = (By.XPATH, "//select[@name='productId']/option")
    # 测试开始时间
    test_begin_time_input = (By.XPATH, "//input[@name='params[beginTime]']")
    # 测试结束时间
    test_end_time_input = (By.XPATH, "//input[@name='params[endTime]']")
    # this-table头复选框
    table_thead_checkbox = (By.XPATH, "//table[@id='bootstrap-table']/thead/tr//input")
    # this-导出测试数据按钮
    export_test_data_btn = (By.XPATH, "//a[@onclick='exportDataReport();']")
    # 搜索按钮
    search_btn = (By.XPATH, "//a[@onclick='$.table.search()']")
    # 导出数据
    export_data_btn = (By.XPATH, "//a[contains(@onclick,'exportDataReport();')]")


    # 加载框
    layer_reload = (By.XPATH, "//div[@class='loaderbox']/div")

 elements/group_report_elements.py

New file
@@ -0,0 +1,36 @@
from selenium.webdriver.common.by import By


class GroupReportElements:
    # 查看评测报告tab_name
    tab_name_report = "组别报告"

    # this-iframe
    this_iframe = (By.XPATH, "//iframe[contains(@src,'/exam/groupReport')]")
    # 新增组别报告iframe
    add_iframe = (By.XPATH, "//iframe[contains(@src,'/exam/groupReport/add')]")

    # 新增按钮
    add_btn = (By.XPATH, "//a[@onclick='$.operate.add()']")
    # 删除按钮
    delete_btn = (By.XPATH, "//a[@onclick='$.operate.removeAll()']")
    # 第一个组别数据按钮
    group_data_btn = (By.XPATH, "//a[contains(@onclick,'downGroupData')]")
    # 第一个组别报告按钮
    group_report_btn = (By.XPATH, "//a[contains(@onclick,'downReport')]")
    # 搜索按钮
    search_btn = (By.XPATH, "//a[@onclick='$.table.search()']")

    # add-名称
    add_name_input = (By.XPATH, "//input[@name='name']")
    # add-导入数据
    add_load_file_input = (By.XPATH, "//input[@name='locationFile']")

    # this-二次确认按钮
    layer_confirm_btn = (By.XPATH, "//div/a[text()='确认']")

    # this-table头复选框
    table_thead_checkbox = (By.XPATH, "//table[@id='bootstrap-table']/thead/tr//input")

    # 加载框
    layer_reload = (By.XPATH, "//div[@class='loaderbox']/div")

 elements/home_elements.py

@@ -1,8 +1,17 @@
from selenium.webdriver.common.by import By

elements = [
    {'name': 'menu_ul', 'desc': '侧边栏菜单', 'loc': (By.XPATH, "//ul[@id='side-menu']"), 'action': None}
]


class HomeElements:
    # 侧边栏菜单
    menu_ul = (By.XPATH, "//ul[@id='side-menu']")
    # 用户菜单3
    user_menu_3 = (By.XPATH, "//ul[@class='nav navbar-top-links navbar-right welcome-message']/li[3]")
    # 登出按钮
    logout_btn = (By.XPATH, "//a[@href='logout']")


    # page所有tab的a标签
    nav_tabs = (By.XPATH, "//nav[@class='page-tabs menuTabs']/div/a")

 elements/login_elements.py

@@ -1,6 +1,13 @@
from selenium.webdriver.common.by import By


# elements = [
#     {'name': 'username_ipt', 'desc': '用户名输入', 'loc': (By.XPATH, "//form//input[@name='username']"), 'action': 'send_keys()'},
#     {'name': 'password_ipt', 'desc': '登录密码输入', 'loc': (By.XPATH, "//form//input[@name='password']"), 'action': 'send_keys()'},
#     {'name': 'code_ipt', 'desc': '验证码输入', 'loc': (By.XPATH, "//form//input[@name='validateCode']"), 'action': 'send_keys()'},
#     {'name': 'login_btn', 'desc': '登录按钮点击', 'loc': (By.XPATH, "//form//button"), 'action': 'click()'},
# ]

class LoginElements:
    # 登录用户名输入框
    username_input = (By.XPATH, "//form//input[@name='username']")
@@ -10,4 +17,5 @@
    validate_code_input = (By.XPATH, "//form//input[@name='validateCode']")
    # 登录按钮
    login_btn = (By.XPATH, "//form//button")

    # 首页左上logo
    home_logo = (By.XPATH, "//span[text()='TAI-OTS']")

 elements/maq_answer_elements.py

@@ -1,9 +1,22 @@
from selenium.webdriver.common.by import By

# elements = [
#     {'name': 'start_btn', 'desc': '开始测试按钮', 'loc': (By.XPATH, "//button"), 'action': 'click()'},
#     {'name': 'options', 'desc': '题目选项', 'loc': (By.XPATH, "//span[@class='q-item-span-content']"), 'action': None},
#     {'name': 'continue_testing_btn', 'desc': '继续测试按钮', 'loc': (By.XPATH, "//button/span[text()='继续测试']"), 'action': None},
#     {'name': 'submit_btn', 'desc': '提交按钮', 'loc': (By.XPATH, "//button/span[contains(text(),'提交')]/.."), 'action': None},
#     {'name': 'upload_success_title', 'desc': '上传成功标题',
#      'loc': (By.XPATH, "//main/h2[contains(text(), '数据已经成功地上传至服务器')]"), 'wait': 10, 'action': 'text()'},
#     {'name': 'loading_text', 'desc': '加载框文字', 'loc': (By.XPATH, "//div[@class='el-loading-spinner']/p"),
#      'action': 'text()'},
#     {'name': 'title', 'desc': '标题文字', 'loc': (By.XPATH, "//div[@class='align-center']/span[2]"), 'wait': 10, 'action': 'text()'},
# ]

class MAQAnswerElements:
    # 开始测试按钮
    start_btn = (By.XPATH, "//button")
    # 题目
    q_title = (By.XPATH, "//div[@class='q-title']")
    # 题目选项
    options = (By.XPATH, "//span[@class='q-item-span-content']")
    # 禁用的选项
@@ -14,10 +27,14 @@
    submit_btn = (By.XPATH, "//button/span[contains(text(),'提交')]/..")
    # 上传成功标题
    upload_success_title = (By.XPATH, "//main/h2[contains(text(), '数据已经成功地上传至服务器')]")
    # 上传成功标题
    network_exception_title = (By.XPATH, "//main/h2[contains(text(), '网络异常')]")

    # 加载框文字
    loading_text = (By.XPATH, "//div[@class='el-loading-spinner']/p")

    # 事中提示语内容
    hint_text = (By.XPATH, "//main[@class='el-main']/div/p[2]/span[3]/font")

    # 标题文字
    title = (By.XPATH, "//div[@class='align-center']/span[2]")


 elements/member_detail_elements.py

New file
@@ -0,0 +1,95 @@
from selenium.webdriver.common.by import By


class MemberDetailElements:
    # 发送状态tab_name
    tab_name_send_status = "查看发送状态"
    # 查看报告tab_name
    tab_name_report = "查看发送状态"
    # 评测人员名单tab_name
    tab_name_member_detail = "评测人员名单"
    # 查看报告邮件发送记录
    tab_name_report_send_log = "查看报告邮件发送记录"

    # 评测人员名单iframe
    this_iframe = (By.XPATH, "//iframe[contains(@src,'/exam/testMember/memberDetail')]")
    # 新增iframe
    add_iframe = (By.XPATH, "//iframe[contains(@src,'/exam/testMember/add')]")
    # 修改测试包iframe
    edit_iframe = (By.XPATH, "//iframe[contains(@src,'/exam/testMember/edit')]")
    # 查看发送状态iframe
    send_status_iframe = (By.XPATH, "//iframe[contains(@src,'/exam/sendtask/condition')]")
    # 查看报告iframe
    report_iframe = (By.XPATH, "//iframe[contains(@src,'/exam/report/member/reportView')]")
    # 查看报告邮件发送记录iframe
    report_send_log_iframe = (By.XPATH, "//iframe[contains(@src,'/exam/report/hrSendlog')]")


    # this-新增按钮
    create_btn = (By.XPATH, "//a[@onclick='$.operate.add()']")
    # this-修改按钮
    edit_btn = (By.XPATH, "//a[@onclick='$.operate.edit()']")
    # this-列表邮箱地址
    table_email_td = (By.XPATH, "//table[@id='bootstrap-table']/tbody/tr/td[4]")
    # this-列表tr
    table_data_tr = (By.XPATH, "//table[@id='bootstrap-table']/tbody/tr")
    # this-table头复选框
    table_thead_checkbox = (By.XPATH, "//table[@id='bootstrap-table']/thead/tr//input")
    # this-table第一行tr查看报告按钮
    table_report_btn = (By.XPATH, "//table[@id='bootstrap-table']/tbody/tr[1]//a")
    # this-删除按钮
    delete_btn = (By.XPATH, "//a[@onclick='$.operate.removeAll()']")
    # this-导出按钮
    export_btn = (By.XPATH, "//a[@onclick='$.table.exportExcel()']")
    # this-批量导入按钮
    import_btn = (By.XPATH, "//a[@onclick='importExcel()']")
    # this-文件上传输入框
    import_input = (By.XPATH, "//input[@id='file']")
    # this-导入成功提示
    import_success_text = (By.XPATH, "//div[contains(text(), '恭喜')]")
    # 确认导入按钮
    import_confirm_btn = (By.XPATH, "//a[contains(text(), '导入')]")
    # this-发送邮件按钮
    send_email_btn = (By.XPATH, "//a[@onclick='javascript:sendEmail()']")
    # this-发送短信按钮
    send_sms_btn = (By.XPATH, "//a[@onclick='javascript:sendSms()']")
    # this-导出测试链接按钮
    export_url_btn = (By.XPATH, "//a[@onclick='exportExcelTestLink()']")
    # this-查看报告邮件发送记录按钮
    report_send_log_btn = (By.XPATH, "//a[@onclick='opensendHrlog()']")
    # this-查看发送状态按钮
    send_status_btn = (By.XPATH, "//a[@onclick='opensendlog()']")
    # this-二次确认按钮
    layer_confirm_btn = (By.XPATH, "//div/a[text()='确认']")

    # add-姓名
    add_member_name_input = (By.XPATH, "//input[@name='memberName']")
    # add-部门
    add_member_dept_input = (By.XPATH, "//input[@name='memberDept']")
    # add-邮箱
    add_member_email_input = (By.XPATH, "//textarea[@name='memberEmail']")
    # add-手机号码
    add_member_phone_input = (By.XPATH, "//input[@name='memberPhone']")
    # add-备注
    add_remark_input = (By.XPATH, "//input[@name='remark']")
    # add-确认按钮
    add_confirm_btn = (By.XPATH, "//iframe[contains(@src,'/exam/testMember/add')]/../../div[3]/a[1]")

    # edit-确认按钮
    edit_confirm_btn = (By.XPATH, "//iframe[contains(@src,'/exam/testMember/edit')]/../../div[3]/a[1]")
    edit_cancel_btn = (By.XPATH, "//iframe[contains(@src,'/exam/testMember/edit')]/../../div[3]/a[2]")

    # send_status-table列表tr
    send_status_table_tr = (By.XPATH, "//table[@id='bootstrap-table']/tbody/tr")

    # report_send_log-HR邮件补发
    hr_resend_btn = (By.XPATH, "//a[@onclick='reissueEmailNew(1)']")
    # report_send_log-测试者邮件补发
    member_resend_btn = (By.XPATH, "//a[@onclick='reissueEmailNew(2)']")
    # report_send_log-table第一行重试次数
    resend_number_text = (By.XPATH, "//table[@id='bootstrap-table']/tbody/tr[1]/td[10]")

    # 操作成功弹窗
    operate_success_layer = (By.XPATH, "//div[text()='操作成功']")
    # 加载框
    layer_reload = (By.XPATH, "//div[@class='loaderbox']/div")

 elements/product_accredit__elements.py

New file
@@ -0,0 +1,35 @@
from selenium.webdriver.common.by import By


class ProductAccreditElements:
    # 查看评测报告tab_name
    tab_name_report = "产品包授权"

    # this-iframe
    this_iframe = (By.XPATH, "//iframe[contains(@src,'/exam/paper/dis')]")
    # 授权窗口
    accredit_iframe = (By.XPATH, "//iframe[contains(@src,'/exam/paper/edit/')]")

    # 用户名框
    search_username_input = (By.XPATH, "//input[@name='loginName']")
    # 搜索按钮
    search_btn = (By.XPATH, "//a[@onclick='$.table.search()']")
    # this-table头复选框
    table_thead_checkbox = (By.XPATH, "//table[@id='bootstrap-table']/thead/tr//input")

    # 产品包授权按钮
    product_btn = (By.XPATH, "//a[contains(@onclick,'$.operate.edit')]")

    # 授权窗口产品包列表select
    accredit_product_select = (By.XPATH, "//select[@name='prodId']")
    # 授权窗口产品包列表option
    accredit_product_option = (By.XPATH, "//select[@name='prodId']/option")
    # 报告模板第一个
    accredit_temp_checkbox = (By.XPATH, "//ui[@id='tempB']/li[1]/span/input")
    # 产品包授权按钮
    accredit_accredit_btn = (By.XPATH, "//a[contains(@onclick,'insertRow()')]")
    # this-二次确认按钮
    layer_confirm_btn = (By.XPATH, "//div/a[text()='确认']")

    # 加载框
    layer_reload = (By.XPATH, "//div[@class='loaderbox']/div")

 elements/report_elements.py

New file
@@ -0,0 +1,27 @@
from selenium.webdriver.common.by import By


class ReportElements:
    # 查看评测报告tab_name
    tab_name_report = "查看评测报告"

    # this-iframe
    this_iframe = (By.XPATH, "//iframe[contains(@src,'/exam/report/reportView')]")

    # 重新生成报告并导出
    generate_export_btn = (By.XPATH, "//a[@onclick='exportDetailReportExcel();']")

    # 下载已生成报告
    download_report_btn = (By.XPATH, "//a[@onclick='exportSendedReportExcel();']")

    # 导出报告
    export_btn = (By.XPATH, "//a[contains(@onclick,'testerReport')]")

    # 导出数据
    export_data_btn = (By.XPATH, "//a[contains(@onclick,'exportDataReport();')]")

    # this-table头复选框
    table_thead_checkbox = (By.XPATH, "//table[@id='bootstrap-table']/thead/tr//input")

    # 加载框
    layer_reload = (By.XPATH, "//div[@class='loaderbox']/div")

 elements/share_add_elements.py

@@ -1,6 +1,40 @@
from selenium.webdriver.common.by import By


# elements = [
#     {'name': 'name_input', 'desc': '姓名文本框', 'loc': (By.XPATH, "//input[@name='memberName']"), 'action': 'send_keys()'},
#     {'name': 'email_input', 'desc': '邮箱文本框', 'loc': (By.XPATH, "//textarea[@name='memberEmail']"), 'action': 'send_keys()'},
#     {'name': 'phone_input', 'desc': '手机号码文本框', 'loc': (By.XPATH, "//textarea[@name='memberPhone']"), 'action': 'send_keys()'},
#     {'name': 'submit_btn', 'desc': '提交按钮', 'loc': (By.XPATH, "//button"), 'wait': 10, 'action': 'click()'},
#
#     {'name': 'test_url_text', 'desc': '测试链接', 'loc': (By.XPATH, "//a"), 'action': 'text()'},
#
#     {'name': 'fill_email_input', 'desc': '基本信息-电子邮箱', 'loc': (By.XPATH, "//form/div[2]//input"), 'action': 'send_keys()'},
#     {'name': 'fill_position_input', 'desc': '基本信息-职位', 'loc': (By.XPATH, "//form/div[3]//input"), 'action': 'send_keys()'},
#     {'name': 'fill_dept_input', 'desc': '基本信息-部门', 'loc': (By.XPATH, "//form/div[4]//input"), 'action': 'send_keys()'},
#
#     {'name': 'ciaq_email_input', 'desc': 'ciaq-邮箱', 'loc': (By.XPATH, "//form/div[2]//input"), 'action': 'send_keys()'},
#     {'name': 'ciaq_sex_select', 'desc': 'ciaq-性别选择', 'loc': (By.XPATH, "//form/div[3]//input"), 'optionsLoc': (By.XPATH, "//form/div[3]//ul/li[contains(@class,'el-select-dropdown__item')]/span"), 'action': 'select()'},
#     {'name': 'ciaq_age_input', 'desc': 'ciaq-年龄', 'loc': (By.XPATH, "//form/div[4]//input"), 'action': 'send_keys()'},
#     {'name': 'ciaq_grade_select', 'desc': 'ciaq-年级选择', 'loc': (By.XPATH, "//form/div[5]//input"), 'optionsLoc': (By.XPATH, "//form/div[5]//ul/li[contains(@class,'el-select-dropdown__item')]/span"), 'action': 'select()'},
#     {'name': 'ciaq_address_input', 'desc': 'ciaq-高中地址', 'loc': (By.XPATH, "//form/div[6]//input"), 'action': 'send_keys()'},
#     {'name': 'ciaq_university_input', 'desc': 'ciaq-大学名称', 'loc': (By.XPATH, "//form/div[7]//input"), 'action': 'send_keys()'},
#     {'name': 'ciaq_universityAddress_input', 'desc': 'ciaq-大学地址', 'loc': (By.XPATH, "//form/div[8]//input"), 'action': 'send_keys()'},
#     {'name': 'ciaq_college_input', 'desc': 'ciaq-学院名称', 'loc': (By.XPATH, "//form/div[9]//input"), 'action': 'send_keys()'},
#     {'name': 'ciaq_major_input', 'desc': 'ciaq-专业名称', 'loc': (By.XPATH, "//form/div[10]//input"), 'action': 'send_keys()'},
#     {'name': 'ciaq_subject_select', 'desc': 'ciaq-专业类别选择', 'loc': (By.XPATH, "//form/div[11]//input"),
#      'optionsLoc': (By.XPATH, "//form/div[11]//ul/li[contains(@class,'el-select-dropdown__item')]/span"),
#      'action': 'select()'},
#     {'name': 'ciaq_GPA_input', 'desc': 'ciaq-GPA', 'loc': (By.XPATH, "//form/div[12]//input"), 'action': 'send_keys()'},
#     {'name': 'ciaq_work_input', 'desc': 'ciaq-GPA', 'loc': (By.XPATH, "//form/div[13]//input"), 'action': 'send_keys()'},
#     {'name': 'ciaq_status_select', 'desc': 'ciaq-求职状态选择', 'loc': (By.XPATH, "//form/div[14]//input"),
#      'optionsLoc': (By.XPATH, "//form/div[14]//ul/li[contains(@class,'el-select-dropdown__item')]/span"),
#      'action': 'select()'},
#     {'name': 'ciaq_workExperience_select', 'desc': 'ciaq-工作经验选择', 'loc': (By.XPATH, "//form/div[15]//input"),
#      'optionsLoc': (By.XPATH, "//form/div[15]//ul/li[contains(@class,'el-select-dropdown__item')]/span"),
#      'action': 'select()'},
# ]

class ShareAddElements:
    # 姓名
    name = (By.XPATH, "//input[@name='memberName']")

 elements/test_package_list_elements.py

@@ -1,29 +1,91 @@
from selenium.webdriver.common.by import By

# elements = [
#     {'name': 'this_iframe', 'desc': '测试包列表iframe', 'loc': (By.XPATH, "//iframe[@src='/exam/test_package']"), 'action': 'iframe()'},
#     {'name': 'add_iframe', '添加测试包iframe': '侧边栏菜单', 'loc': (By.XPATH, "//iframe[@src='/exam/test_package/add']"), 'action': 'iframe()'},
#     {'name': 'prodTree_iframe', 'desc': '产品包树iframe', 'loc': (By.XPATH, "//iframe[contains(@src,'/exam/product/getProdList')]"), 'action': 'iframe()'},
#     {'name': 'share_iframe', 'desc': '分享iframe', 'loc': (By.XPATH, "//iframe[contains(@src,'/exam/test_package/share')]"), 'action': 'iframe()'},
#
#     {'name': 'create_btn', 'desc': '创建按钮', 'loc': (By.XPATH, "//a[@onclick='$.operate.add()']"), 'action': 'click()'},
#     {'name': 'table_packageName_a', 'desc': '测试包列表测试包名称a标签', 'loc': (By.XPATH, "//table[@id='bootstrap-table']/tbody/tr/td[2]/a"), 'action': None},
#     {'name': 'table_packageName_option', 'desc': '测试包列表测试包名称a标签', 'loc': (By.XPATH, "//table[@id='bootstrap-table']/tbody/tr/td[2]/a"), 'action': 'option()'},
#     {'name': 'table_package_tr', 'desc': '列表tr', 'loc': (By.XPATH, "//table[@id='bootstrap-table']/tbody/tr"), 'action': None},
#     {'name': 'share_1_btn', 'desc': '生成分享链接按钮', 'loc': (By.XPATH, "//a[@onclick='share(1)']"), 'action': 'click()'},
#     {'name': 'delete_btn', 'desc': '删除按钮', 'loc': (By.XPATH, "//a[@onclick='$.operate.removeAll()']"), 'action': 'click()'},
#     {'name': 'delete_confirm_btn', 'desc': '删除确认按钮', 'loc': (By.XPATH, "//div/a[text()='确认']"), 'action': 'click()'},
#
#     {'name': 'add_testPackageName_input', 'desc': 'add-测试包名称输入', 'loc': (By.XPATH, "//input[@name='testName']"), 'action': 'send_keys()'},
#     {'name': 'add_reportCompanyName_input', 'desc': 'add-报告企业名称输入', 'loc': (By.XPATH, "//input[@name='reportCompanyName']"), 'action': 'send_keys()'},
#     {'name': 'add_testPackageType_select', 'desc': 'add-类型选择', 'loc': (By.XPATH, "//select[@name='testType']/../span"), 'optionsLoc': (By.XPATH, "//ul[contains(@id,'select2-testType')]/li"), 'action': 'select()'},
#     {'name': 'add_testPackageArea_select', 'desc': 'add-区域选择', 'loc': (By.XPATH, "//select[@name='testArea']/../span"), 'optionsLoc': (By.XPATH, "//ul[contains(@id,'select2-testArea')]/li"), 'action': 'select()'},
#     {'name': 'add_prodTree_btn', 'desc': 'add-产品包树弹出按钮', 'loc': (By.XPATH, "//span[@onclick='selectProdTree()']"), 'action': 'click()'},
#     {'name': 'add_hrEmail_input', 'desc': 'add-HR接收报告邮箱输入', 'loc': (By.XPATH, "//input[@name='testEmail']"), 'action': 'send_keys()'},
#     {'name': 'add_invalidTime_input', 'desc': 'add-有效期输入', 'loc': (By.XPATH, "//input[@name='invalidTime']"), 'action': 'send_keys()'},
#     {'name': 'add_invalidTime_btn', 'desc': 'add-有效期点击', 'loc': (By.XPATH, "//input[@name='invalidTime']"), 'action': 'click()'},
#     {'name': 'add_templateLangType_select', 'desc': 'add-测试者邀请邮件内容模板选择', 'loc': (By.XPATH, "//select[@name='templateLangType']/../button"), 'optionsLoc': (By.XPATH, "//select[@name='templateLangType']/../div/div/ul/li/a/span[2]"), 'action': 'select()'},
#     {'name': 'add_hrTemplateLangType_select', 'desc': 'add-hr语言类型选择', 'loc': (By.XPATH, "//select[@name='hrTemplateLangType']/../button"), 'optionsLoc': (By.XPATH, "//select[@name='hrTemplateLangType']/../div/div/ul/li/a/span[2]"), 'action': 'select()'},
#     {'name': 'add_reportTemplateId_select', 'desc': 'add-报告模板选择', 'loc': (By.XPATH, "//select[@name='reportTemplateId']/../button"), 'optionsLoc': (By.XPATH, "//select[@name='reportTemplateId']/../div/div/ul/li/a/span[2]"), 'action': 'select()'},
#     {'name': 'add_position_input', 'desc': 'add-要评价的岗位输入', 'loc': (By.XPATH, "//input[@name='position']"), 'action': 'send_keys()'},
#     {'name': 'add_professionalCategory_input', 'desc': 'add-职业大类输入', 'loc': (By.XPATH, "//input[@name='professionalCategory']"), 'action': 'send_keys()'},
#     {'name': 'add_superiorPosition_input', 'desc': 'add-上级岗位输入', 'loc': (By.XPATH, "//input[@name='superiorPosition']"), 'action': 'send_keys()'},
#     {'name': 'add_autoSendReport_checkbox', 'desc': 'add-测试者接收报告复选框', 'loc': (By.XPATH, "//input[@name='autoSendReport']"), 'action': 'click()'},
#     {'name': 'add_memberTemplateLangType_select', 'desc': 'add-测试者报告语言类型选择', 'loc': (By.XPATH, "//select[@name='memberTemplateLangType']/../button"), 'optionsLoc': (By.XPATH, "//select[@name='memberTemplateLangType']/../div/div/ul/li/a/span[2]"), 'action': 'select()'},
#     {'name': 'add_code_checkbox', 'desc': 'add-人口学编码选框', 'loc': (By.XPATH, "//label[@class='check-box']"), 'action': None},
#     {'name': 'add_confirm_btn', 'desc': 'add-确认按钮', 'loc': (By.XPATH, "//iframe[@src='/exam/test_package/add']/../../div[3]/a[1]"), 'action': 'click()'},
#
#     {'name': 'prodTree_option', 'desc': 'prodTree-产品包选项', 'loc': (By.XPATH, "//div[@id='tree']/li/a/span[2]"), 'action': 'option()'},
#     {'name': 'prodTree_confirm_btn', 'desc': 'proTree-确认按钮', 'loc': (By.XPATH, "//iframe[contains(@src,'/exam/product/getProdList')]/../../div[3]/a[1]"), 'action': 'click()'},
#
#     {'name': 'share_url_text', 'desc': 'share-url文本', 'loc': (By.XPATH, "//input[@id='shareUrl']"), 'action': 'value_js()'},
#     {'name': 'share_cancel_btn', 'desc': 'share-关闭按钮', 'loc': (By.XPATH, "//iframe[contains(@src,'/exam/test_package/share')]/../../div[3]/a[2]"), 'action': 'click()'},
#
#
# ]

class TestPackageListElements:
    # this-tab
    tab_name_this = "测试包列表"


    # 测试包列表iframe
    this_iframe = (By.XPATH, "//iframe[@src='/exam/test_package']")
    # 添加测试包iframe
    add_iframe = (By.XPATH, "//iframe[@src='/exam/test_package/add']")
    # 修改测试包iframe
    edit_iframe = (By.XPATH, "//iframe[contains(@src,'/exam/test_package/edit')]")
    # 产品包树iframe
    prodTree_iframe = (By.XPATH, "//iframe[contains(@src,'/exam/product/getProdList')]")
    # 分享iframe
    share_iframe = (By.XPATH, "//iframe[contains(@src,'/exam/test_package/share')]")

    # 事中提示语iframe
    hint_iframe = (By.XPATH, "//iframe[contains(@src,'/exam/test_package/editHint')]")
    # 查看报告iframe
    report_iframe = (By.XPATH, "//iframe[contains(@src,'/exam/report/reportView')]")

    # this-创建按钮
    create_btn = (By.XPATH, "//a[@onclick='$.operate.add()']")
    # this-修改按钮
    edit_btn = (By.XPATH, "//a[@onclick='$.operate.edit()']")
    # this-测试包列表测试包名称a标签
    table_packageName_a = (By.XPATH, "//table[@id='bootstrap-table']/tbody/tr/td[2]/a")
    # this-列表tr
    table_package_tr = (By.XPATH, "//table[@id='bootstrap-table']/tbody/tr")
    # this-table头复选框
    table_thead_checkbox = (By.XPATH, "//table[@id='bootstrap-table']/thead/tr//input")
    # this-生成分享链接按钮
    share_1_btn = (By.XPATH, "//a[@onclick='share(1)']")
    # this-回收测试包按钮
    recover_btn = (By.XPATH, "//a[@onclick='javascript:recover()']")
    # this-事中提示语按钮
    hint_btn = (By.XPATH, "//a[@onclick='editHint()']")
    # this-报告按钮
    report_btn = (By.XPATH, "//a[@onclick='javascript:testReport()']")
    # this-删除按钮
    delete_btn = (By.XPATH, "//a[@onclick='$.operate.removeAll()']")
    # this-删除确认按钮
    delete_confirm_btn = (By.XPATH, "//div/a[text()='确认']")
    # this-二次确认按钮
    layer_confirm_btn = (By.XPATH, "//div/a[text()='确认']")

    # add-测试包名称
    add_testPackageName_input = (By.XPATH, "//input[@name='testName']")
@@ -31,12 +93,18 @@
    add_reportCompanyName_input = (By.XPATH, "//input[@name='reportCompanyName']")
    # add-类型
    add_testPackageType_select = (By.XPATH, "//select[@name='testType']/../span")
    # add-类型文本
    add_testPackageType_text = (By.XPATH, "//select[@name='testType']/../span/span/span/span[1]")
    # add-类型选项
    add_testPackageType_option = (By.XPATH, "//ul[contains(@id,'select2-testType')]/li")
    # add-区域
    add_testPackageArea_select = (By.XPATH, "//select[@name='testArea']/../span")
    # add-区域文本
    add_testPackageArea_text = (By.XPATH, "//select[@name='testArea']/../span/span/span/span[1]")
    # add-区域选项
    add_testPackageArea_option = (By.XPATH, "//ul[contains(@id,'select2-testArea')]/li")
    # add-产品包输入框
    add_prodTree_input = (By.XPATH, "//input[@name='prodName']")
    # add-产品包树弹出按钮
    add_prodTree_btn = (By.XPATH, "//span[@onclick='selectProdTree()']")
    # add-HR接收报告邮箱
@@ -47,30 +115,43 @@
    add_templateLangType_select = (By.XPATH, "//select[@name='templateLangType']/../button")
    # add-测试者邀请邮件内容模板选项
    add_templateLangType_option = (By.XPATH, "//select[@name='templateLangType']/../div/div/ul/li/a/span[2]")
    # add-测试者邀请邮件内容
    add_templateLangType_text = (By.XPATH, "//textarea[@name='template']")
    # add-HR语言类型
    add_hrTemplateLangType_select = (By.XPATH, "//select[@name='hrTemplateLangType']/../button")
    # add-HR语言类型选项
    add_hrTemplateLangType_option = (By.XPATH, "//select[@name='hrTemplateLangType']/../div/div/ul/li/a/span[2]")
    # add-测试者邀请邮件内容
    add_hrTemplateLangType_text = (By.XPATH, "//textarea[@name='hrTemplate']")
    # add-报告模板
    add_reportTemplateId_select = (By.XPATH, "//select[@name='reportTemplateId']/../button")
    # add-报告模板选项
    add_reportTemplateId_option = (By.XPATH, "//select[@name='reportTemplateId']/../div/div/ul/li/a/span[2]")
    # add-报告模板内容
    add_reportTemplateId_text = (By.XPATH, "//select[@name='reportTemplateId']/../button/div/div/div")
    # add-要评价的岗位
    add_position_input = (By.XPATH, "//input[@name='position']")
    # add-职业大类
    add_professionalCategory_input = (By.XPATH, "//input[@name='professionalCategory']")
    # add-上级岗位
    add_superiorPosition_input = (By.XPATH, "//input[@name='superiorPosition']")
    # add-报告模板选项
    add_reportTemplateId_option = (By.XPATH, "//select[@name='reportTemplateId']/../div/div/ul/li/a/span[2]")
    # add-测试者接收报告
    add_autoSendReport_checkbox = (By.XPATH, "//input[@name='autoSendReport']")
    # add-测试者报告语言类型
    add_memberTemplateLangType_select = (By.XPATH, "//select[@name='memberTemplateLangType']/../button")
    add_memberReportLangType_select = (By.XPATH, "//select[@name='memberTemplateLangType']/../button")
    # add-测试者报告语言类型选项
    add_memberTemplateLangType_option = (By.XPATH, "//select[@name='memberTemplateLangType']/../div/div/ul/li/a/span[2]")
    add_memberReportLangType_option = (By.XPATH, "//select[@name='memberTemplateLangType']/../div/div/ul/li/a/span[2]")
    # add-测试者报告内容
    add_memberReportLangType_text = (By.XPATH, "//textarea[@name='memberTemplate']")
    # 人口学编码选项
    add_code_checkbox = (By.XPATH, "//label[@class='check-box']")
    # add-确认按钮
    add_confirm_btn = (By.XPATH, "//iframe[@src='/exam/test_package/add']/../../div[3]/a[1]")

    # edit-确认按钮
    edit_confirm_btn = (By.XPATH, "//iframe[contains(@src,'/exam/test_package/edit')]/../../div[3]/a[1]")
    edit_cancel_btn = (By.XPATH, "//iframe[contains(@src,'/exam/test_package/edit')]/../../div[3]/a[2]")


    # prodTree-产品包选项
    prodTree_option = (By.XPATH, "//div[@id='tree']/li/a/span[2]")
@@ -81,3 +162,14 @@
    share_url_input = (By.XPATH, "//input[@id='shareUrl']")
    # share-关闭按钮
    share_cancel_btn = (By.XPATH, "//iframe[contains(@src,'/exam/test_package/share')]/../../div[3]/a[2]")

    # hint-第四个指导语文本域
    hint_textarea = (By.XPATH, "//div[@class='ibox float-e-margins']/div/div[10]//textarea")
    # hint-模态窗口文本标签
    hint_modal_span = (By.XPATH, "//div[@id='modalWindow']//div[@class='note-editable']/p[3]/font/span")
    # hint-模态窗口保存按钮
    hint_modal_save_btn = (By.XPATH, "//div[@id='modalWindow']//div[@class='modal-footer']/button[@id='save']")


    # 操作成功弹窗
    operate_success_layer = (By.XPATH, "//div[text()='操作成功']")

 import/member_import.xlsx

Binary files differ

 po/caq_answer_page.py

@@ -1,7 +1,7 @@
import random

from base.base_page import BasePage
from elements.caq_answer_elements import CAQAnswerElements as Answer
from elements.caq_answer_elements import CAQAnswerElements
from selenium.common.exceptions import *

import time
@@ -13,52 +13,56 @@
    """
    loading_count = 0

    es = CAQAnswerElements

    def answer(self):
        # 点击开始按钮
        self.click(self.es.start_btn, timeout=10)
        # 暂停3秒
        time.sleep(3)
        i = 0
        while i < 27:
            if i == 0:
                self.click_wait(Answer.continue_testing_btn)
                self.click(self.es.continue_testing_btn, timeout=10)
            elif i < 4:
                # 获取到所有选项
                options_1 = self.elements_is_visibility(Answer.options_1)
                options_1 = self.elements_is_visibility(self.es.options_1)
                number = random.randint(0, 4)
                self.click_element_js(options_1[number])

                options_2 = self.elements_is_visibility(Answer.options_2)
                options_2 = self.elements_is_visibility(self.es.options_2)
                self.click_element_js(options_2[number])

                options_3 = self.elements_is_visibility(Answer.options_3)
                options_3 = self.elements_is_visibility(self.es.options_3)
                self.click_element_js(options_3[number])

                options_4 = self.elements_is_visibility(Answer.options_4)
                options_4 = self.elements_is_visibility(self.es.options_4)
                self.click_element_js(options_4[number])

                options_5 = self.elements_is_visibility(Answer.options_5)
                options_5 = self.elements_is_visibility(self.es.options_5)
                self.click_element_js(options_5[number])

                self.click_js(Answer.next_btn)
                self.click_js(self.es.next_btn)
            if i == 4:
                self.click_wait(Answer.continue_testing_btn)
                self.click(self.es.continue_testing_btn, timeout=10)

            # # 标题不存在直接返回False
            # if not self.title_is_display():
            #     return False

            if 4 < i < 26:
                options_6 = self.elements_is_visibility(Answer.options_6)
                options_6 = self.elements_is_visibility(self.es.options_6)
                number = random.randint(0, 4)
                self.click_element_js(options_6[number])
                if i == 23:
                    self.click_js(Answer.submit_btn)
                    self.click_js(self.es.submit_btn)
                    # 数据是否上传完成
                    time.sleep(15)
                    if self.upload_is_success():
                        return True
                else:

                    self.click_js(Answer.next_btn)
                    self.click_js(self.es.next_btn)
            i += 1

    def upload_is_success(self):
@@ -69,7 +73,7 @@
        i = 0
        while i < 60:
            try:
                self.get_element_wait(Answer.upload_success_title)
                self.get_element_wait(self.es.upload_success_title)
                return True
            except TimeoutException:
                i += 1
@@ -82,7 +86,7 @@
        :return:
        """
        try:
            button = self.get_element(Answer.submit_btn)
            button = self.get_ele(self.es.submit_btn)
            if button.is_enabled():
                return True
            else:
@@ -97,7 +101,7 @@
        """
        try:
            # 点击继续测试按钮
            button = self.get_element(Answer.continue_testing_btn)
            button = self.get_ele(self.es.continue_testing_btn)
            if button.is_enabled():
                return True
            else:
@@ -112,7 +116,7 @@
        """
        try:
            # 获取标题
            self.get_element_wait(Answer.title)
            self.get_element_wait(self.es.title)
            return True
        except TimeoutException:
            return False
@@ -125,7 +129,7 @@
        i = 0
        while i < 10:
            try:
                self.get_element(Answer.loading_text)
                self.get_element(self.es.loading_text)
                i += 1
                time.sleep(1)
            except:
@@ -138,4 +142,4 @@
        开始测试按钮
        :return:
        """
        self.click_wait(Answer.start_btn)
        self.click_wait(self.es.start_btn)

 po/export_test_data_page.py

New file
@@ -0,0 +1,38 @@
import time

from base.base_page import BasePage
from elements.export_test_data_elements import ExportTestDataElements
from selenium.common.exceptions import TimeoutException, NoSuchElementException


class ExportTestDataPage(BasePage):
    """
    导出测试数据页面
    """
    # 页面元素
    es = ExportTestDataElements

    def __init__(self, driver):
        super().__init__(driver)
        try:
            self.driver.switch_to.default_content()
            self.switch_iframe(self.es.this_iframe)
        except:
            pass

    def wait_layer_reload_hide(self, timeout=600):
        """
        等待加载框消失
        :param timeout: 超时时间
        :return:
        """
        for i in range(1, 600):
            try:
                # 加载框存在睡眠一秒
                self.get_ele(self.es.layer_reload)
                time.sleep(1)
            except NoSuchElementException:
                # 不存在跳出循环
                break



 po/group_report_page.py

New file
@@ -0,0 +1,27 @@
from base.base_page import BasePage
from elements.group_report_elements import GroupReportElements
from selenium.common.exceptions import TimeoutException


class GroupReportPage(BasePage):
    """
    组别报告页面
    """
    # 页面元素
    es = GroupReportElements

    def __init__(self, driver):
        super().__init__(driver)
        try:
            self.driver.switch_to.default_content()
            self.switch_iframe(self.es.this_iframe)
        except:
            pass









 po/home_page.py

@@ -1,5 +1,6 @@
from base.base_page import BasePage
from selenium.webdriver.common.by import By
from elements.home_elements import HomeElements
import time


@@ -7,6 +8,20 @@
    """
    主页面侧边栏菜单与tab栏操作页面
    """

    es = HomeElements

    def __init__(self, driver):
        super().__init__(driver)
        self.driver = driver
        # 切换到最顶层的文档
        driver.switch_to.default_content()

    def logout(self):
        # 点击第三个用户菜单
        self.click(self.es.user_menu_3)
        # 点击登出
        self.click(self.es.logout_btn)

    def menu_select(self, menu_text, is_first=True):
        """
@@ -29,19 +44,34 @@
        if is_first:
            # 菜单元素定位
            menu_loc = (By.XPATH, "//ul[@id='side-menu']//span[text()='" + menu + "']")
            # 获取菜单元素
            menu_element = self.get_element(menu_loc)
            # 点击菜单
            menu_element.click()
            time.sleep(1)
            # 菜单下ul定位
            menu_ul_loc = (By.XPATH, "//ul[@id='side-menu']//span[text()='" + menu + "']/../../ul")
            # 获取到ul元素
            ul = self.get_ele(menu_ul_loc)
            # 获取ul的class属性
            ul_class = ul.get_attribute("class")
            # 判断class是否包含in字符串
            if "in" not in ul_class:
                # 不包含则为未打开状态，可以点击
                self.click(menu_loc, timeout=10)
        else:
            # 菜单元素定位
            menu_loc = (By.XPATH, "//ul[@id='side-menu']//a[text()='" + menu + "']")
            # 获取菜单元素
            menu_element = self.get_element(menu_loc)
            # 点击菜单
            menu_element.click()
            time.sleep(1)
            # 判断menu_text是否还包含/
            if "/" in menu_text:
                # 包含则表示还有下级菜单，判断下级菜单是否为展开状态
                # 菜单下ul定位
                menu_ul_loc = (By.XPATH, "//ul[@id='side-menu']//a[text()='" + menu + "']/../ul")
                # 获取到ul元素
                ul = self.get_ele(menu_ul_loc)
                # 获取ul的class属性
                ul_class = ul.get_attribute("class")
                # 判断class是否包含in字符串
                if "in" not in ul_class:
                    # 不包含则为未打开状态，可以点击
                    self.click(menu_loc, timeout=10)
            else:
                self.click(menu_loc, timeout=10)

        if "/" in menu_text:
            # 获取/第一次出现的位置
@@ -50,3 +80,14 @@
            menu_text = menu_text[index + 1: len(menu_text)]
            # 递归调用
            self.menu_select(menu_text, False)



    def close_tab(self, tab_name):
        """关闭页面tab"""
        # 获取所有tab
        tabs = self.get_eles(self.es.nav_tabs)
        for tab in tabs:
            if tab.text == tab_name:
                # 点击关闭图标
                tab.find_element(By.XPATH, "i").click()

 po/login_page.py

@@ -1,65 +1,43 @@
from base.base_page import BasePage
from elements.login_elements import LoginElements as Login
from elements.login_elements import LoginElements
from selenium.common.exceptions import TimeoutException


class LoginPage(BasePage):
    """
    登录页面
    """
    # 页面元素
    es = LoginElements

    def username_input(self, username):
        """
        填写用户名
        :param username: 用户名
        :return:
        """
        self.send_text(username, Login.username_input)
    def __init__(self, driver):
        super().__init__(driver)
        self.driver = driver
        # 切换到最顶层文档
        driver.switch_to.default_content()

    def password_input(self, password):
        """
        填写密码
        :param password: 密码
        :return:
        """
        self.send_text(password, Login.password_input)
    def login(self, username, password, code):
        # 输入用户名
        self.fill(self.es.username_input, username)
        # 输入密码
        self.fill(self.es.password_input, password)
        # 输入验证码
        self.fill(self.es.validate_code_input, code)
        # 点击登录按钮
        self.click(self.es.login_btn)

    def validate_code_input(self, validate_code):
        """
        填写验证码
        :param validate_code: 验证码
        :return:
        """
        self.send_text(validate_code, Login.validate_code_input)

    def login_btn(self):
        """
        点击登录按钮
        :return:
        """
        self.click(Login.login_btn)

    def login(self, username, password, validate_code):
        """
        登录
        :param username: 用户名
        :param password: 密码
        :param validate_code: 验证码
        :return:
        """
        self.username_input(username)
        self.password_input(password)
        self.validate_code_input(validate_code)
        self.login_btn()

    def is_login_success(self):
    def login_assert(self):
        """
        判断是否登录成功
        :return: bool
        """
        current_url = self.driver.current_url
        if "index" in self.driver.current_url:
            return True
        else:
        try:
            ele = self.get_ele(self.es.home_logo, timeout=10)
            if ele.text == "TAI-OTS":
                return True
        except TimeoutException:
            return False





 po/maq_answer_page.py

@@ -1,7 +1,7 @@
import random

from base.base_page import BasePage
from elements.maq_answer_elements import MAQAnswerElements as Answer
from elements.maq_answer_elements import MAQAnswerElements
from selenium.common.exceptions import *

import time
@@ -11,15 +11,30 @@
    """
    答题页面
    """

    loading_count = 0

    def answer(self):
    se = MAQAnswerElements

    def answer(self, hint=None, question: dict = None):
        flag = False
        # 暂停3秒
        time.sleep(3)
        # 点击开始答题
        self.click(self.se.start_btn)
        question_title = None
        while True:
            # time.sleep(0.5)
            # 继续测试按钮出现则点击
            if self.continue_btn_is_display():
                self.click(Answer.continue_testing_btn)
                # 判断hint是否有内容
                if hint:
                    # 获取提示语内容
                    hint_text = self.get_ele(self.se.hint_text).text
                    # 判断提示语内容是否包含传入的hint
                    if hint in hint_text:
                        flag = True
                self.click(self.se.continue_testing_btn)

            # 标题不存在直接返回False
            if not self.title_is_display():
@@ -27,22 +42,41 @@

            try:
                # 获取到所有选项
                options = self.get_elements(Answer.options)
                options = self.get_eles(self.se.options)
                if len(options) < 6:
                    continue
                number = random.randint(0, 5)
                if options[number].is_enabled():
                    # 获取到题目
                    # q_title = self.get_ele(self.se.q_title).text
                    # q_title与question_title不相同则写入question中
                    # 遍历字典
                    # if question:
                    #     for key in question.keys():
                    #         q_title = self.get_ele(self.se.q_title).text
                    #         if question[key]["title"] in q_title and "answer" not in question[key]:
                    #             question[key]["answer"] = number + 1
                    #             question_title = q_title
                    #             break
                    options[number].click()
            except:
                pass

            # 提交按钮存在则点击
            if self.submit_btn_is_display():
                self.click(Answer.submit_btn)
                self.click(self.se.submit_btn)
                # 数据是否上传完成
                time.sleep(15)
                if self.upload_is_success():
                    if hint:
                        return flag
                    return True
                # 是否网络异常
                try:
                    self.get_ele(self.se.network_exception_title)
                    return "网络异常"
                except NoSuchElementException:
                    pass
                return False

    def upload_is_success(self):
@@ -53,7 +87,7 @@
        i = 0
        while i < 60:
            try:
                self.get_element_wait(Answer.upload_success_title)
                self.get_ele(self.se.upload_success_title, timeout=5)
                return True
            except TimeoutException:
                i += 1
@@ -66,7 +100,7 @@
        :return:
        """
        try:
            button = self.get_element(Answer.submit_btn)
            button = self.get_ele(self.se.submit_btn)
            if button.is_enabled():
                return True
            else:
@@ -81,7 +115,7 @@
        """
        try:
            # 点击继续测试按钮
            button = self.get_element(Answer.continue_testing_btn)
            button = self.get_ele(self.se.continue_testing_btn)
            if button.is_enabled():
                return True
            else:
@@ -96,30 +130,23 @@
        """
        try:
            # 获取标题
            self.get_element_wait(Answer.title)
            self.get_ele(self.se.title, timeout=10)
            return True
        except TimeoutException:
            return False

    def loadin_text(self):
        """
        判断加载框加载，如果加载超过10秒直接退出当前测试
        :return:
        """
        i = 0
        while i < 10:
            try:
                self.get_element(Answer.loading_text)
                i += 1
                time.sleep(1)
            except:
                return False
        else:
            return True

    def start_btn(self):
        """
        开始测试按钮
        :return:
        """
        self.click_wait(Answer.start_btn)
    # def loadin_text(self):
    #     """
    #     判断加载框加载，如果加载超过10秒直接退出当前测试
    #     :return:
    #     """
    #     i = 0
    #     while i < 10:
    #         try:
    #             self.oper_elem("")
    #             i += 1
    #             time.sleep(1)
    #         except:
    #             return False
    #     else:
    #         return True

 po/member_detail_page.py

New file
@@ -0,0 +1,164 @@
from base.base_page import BasePage
from selenium.webdriver.common.by import By
from elements.member_detail_elements import MemberDetailElements
from datetime import datetime
import time


class MemberDetailPage(BasePage):
    """
    测试包列表页面
    """

    es = MemberDetailElements

    def __init__(self, driver):
        """初始化时将iframe切换到当前页面"""
        super().__init__(driver)
        try:
            self.driver.switch_to.default_content()
            self.switch_iframe(self.es.this_iframe)
        except:
            pass

    def add_member(self, data: dict):
        """
        新增测评人员
        :param data:
        :return:
        """
        # 点击新增按钮
        self.click(self.es.create_btn)
        # 切换到add的iframe
        self.switch_iframe(self.es.add_iframe)
        # 填写信息
        self.fill(self.es.add_member_name_input, data["name"])
        self.fill(self.es.add_member_dept_input, data["dept"])
        self.fill(self.es.add_member_email_input, data["email"])
        self.fill(self.es.add_member_phone_input, data["phone"])
        self.fill(self.es.add_remark_input, data["remark"])
        # 回到上一层iframe
        self.switch_parent_iframe()
        # 点击确定按钮
        self.click(self.es.add_confirm_btn)
        return data["email"]

    def edit_member(self, memberEmail, data: dict):
        """
        修改测评人员
        :param memberEmail:
        :param data:
        :return:
        """
        # 勾选测评人员
        self.select_email_checkbox(memberEmail)
        # 点击修改按钮
        self.click(self.es.edit_btn)
        # 切换到edit的iframe
        self.switch_iframe(self.es.edit_iframe)
        # 填写信息
        self.fill(self.es.add_member_name_input, data["name"])
        self.fill(self.es.add_member_dept_input, data["dept"])
        self.fill(self.es.add_member_email_input, data["email"])
        self.fill(self.es.add_member_phone_input, data["phone"])
        self.fill(self.es.add_remark_input, data["remark"])
        # 回到上一层iframe
        self.switch_parent_iframe()
        # 点击确定按钮
        self.click(self.es.edit_confirm_btn)
        return data["email"]

    def is_edit_success(self, memberEmail, data: dict):
        """判断是否修改成功"""
        # 勾选测评人员
        self.select_email_checkbox(memberEmail)
        # 点击修改按钮
        self.click(self.es.edit_btn)
        # 切换到edit的iframe
        self.switch_iframe(self.es.edit_iframe)
        # 判断信息
        flag = self.equals(self.es.add_member_name_input, data["name"])
        if not flag:
            return flag
        flag = self.equals(self.es.add_member_dept_input, data["dept"])
        if not flag:
            return flag
        flag = self.equals(self.es.add_member_email_input, data["email"])
        if not flag:
            return flag
        flag = self.equals(self.es.add_member_phone_input, data["phone"])
        if not flag:
            return flag
        flag = self.equals(self.es.add_remark_input, data["remark"])
        if not flag:
            return flag
        # 回到上一层iframe
        self.switch_parent_iframe()
        # 点击关闭按钮
        self.click(self.es.edit_cancel_btn)
        return True

    def is_create_success(self, memberEmail):
        """判断是否创建成功"""
        emails = self.get_eles(self.es.table_email_td)
        for email in emails:
            if email.text == memberEmail:
                return True
        return False

    def is_remote_success(self):
        """判断是否删除成功"""

    def select_email_checkbox(self, memberEmail):
        """
        选中评测人员
        :param memberEmail:
        :return:
        """
        # 获取到table的所有tr
        table_trs = self.get_eles(self.es.table_data_tr)
        for tr in table_trs:
            # 判断复选框是否为选中状态
            tr_class = tr.get_attribute("class")
            if tr_class == "selected":
                # 已点击进行下一次循环
                continue
            # 邮箱在tr中的定位
            email_loc = (By.XPATH, "td[4]")
            # 获取tr中的测试包名称
            tr_email = tr.find_element(*email_loc).text
            if tr_email == memberEmail:
                # 复选框在tr中的定位
                package_checkbox_loc = (By.XPATH, "td[1]/input")
                # 获取复选框元素
                tr_checkbox = tr.find_element(*package_checkbox_loc)
                # 点击复选框
                tr_checkbox.click()
                break

    def unselect_email_checkbox(self, memberEmail):
        """
        选中评测人员
        :param memberEmail:
        :return:
        """
        # 获取到table的所有tr
        table_trs = self.get_eles(self.es.table_data_tr)
        for tr in table_trs:
            # 判断复选框是否为选中状态
            tr_class = tr.get_attribute("class")
            if tr_class != "selected":
                # 已点击进行下一次循环
                continue
            # 邮箱在tr中的定位
            email_loc = (By.XPATH, "td[4]")
            # 获取tr中的测试包名称
            tr_email = tr.find_element(*email_loc).text
            if tr_email == memberEmail:
                # 复选框在tr中的定位
                package_checkbox_loc = (By.XPATH, "td[1]/input")
                # 获取复选框元素
                tr_checkbox = tr.find_element(*package_checkbox_loc)
                # 点击复选框
                tr_checkbox.click()
                break

 po/product_accredit_page.py

New file
@@ -0,0 +1,38 @@
import time

from base.base_page import BasePage
from elements.product_accredit__elements import ProductAccreditElements
from selenium.common.exceptions import TimeoutException, NoSuchElementException


class ProductAccreditPage(BasePage):
    """
    登录页面
    """
    # 页面元素
    es = ProductAccreditElements

    def __init__(self, driver):
        super().__init__(driver)
        try:
            self.driver.switch_to.default_content()
            self.switch_iframe(self.es.this_iframe)
        except:
            pass

    def wait_layer_reload_hide(self, timeout=600):
        """
        等待加载框消失
        :param timeout: 超时时间
        :return:
        """
        for i in range(1, 600):
            try:
                # 加载框存在睡眠一秒
                self.get_ele(self.es.layer_reload)
                time.sleep(1)
            except NoSuchElementException:
                # 不存在跳出循环
                break



 po/report_page.py

New file
@@ -0,0 +1,38 @@
import time

from base.base_page import BasePage
from elements.report_elements import ReportElements
from selenium.common.exceptions import TimeoutException, NoSuchElementException


class ReportPage(BasePage):
    """
    登录页面
    """
    # 页面元素
    es = ReportElements

    def __init__(self, driver):
        super().__init__(driver)
        try:
            self.driver.switch_to.default_content()
            self.switch_iframe(self.es.this_iframe)
        except:
            pass

    def wait_layer_reload_hide(self, timeout=600):
        """
        等待加载框消失
        :param timeout: 超时时间
        :return:
        """
        for i in range(1, 600):
            try:
                # 加载框存在睡眠一秒
                self.get_ele(self.es.layer_reload)
                time.sleep(1)
            except NoSuchElementException:
                # 不存在跳出循环
                break



 po/share_add_page.py

@@ -1,5 +1,5 @@
from base.base_page import BasePage
from elements.share_add_elements import ShareAddElements as Share
from elements.share_add_elements import ShareAddElements
import time


@@ -8,44 +8,23 @@
    分享链接打开的页面
    """

    def name_input(self, name):
        """
        输入姓名
        :param name:
        :return:
        """
        self.send_text(name, Share.name)
    es = ShareAddElements

    def email_input(self, email):
    def get_test_url(self, name, email):
        """
        输入邮箱
        :param email:
        :return:
        """
        self.send_text(email, Share.email)

    def submit_btn(self):
        """
        点击提交
        :return:
        """
        self.click_wait(Share.submit_btn)

    def page_default_operation(self, name, email):
        """
        页面默认操作
        填写信息并提交，返回测试链接
        :param name:
        :param email:
        :return:
        """
        # 输入姓名
        self.name_input(name)
        self.fill(self.es.name, name, timeout=10)
        # 输入邮箱
        self.email_input(email)
        self.fill(self.es.email, email)
        # 点击提交
        self.submit_btn()
        self.click(self.es.submit_btn)
        # 获取测试链接并返回
        return self.get_element_wait(Share.test_url).text
        return self.get_ele(self.es.test_url).text

    def fill_info(self, email, position, dept):
        """
@@ -55,11 +34,10 @@
        :param dept: 部门
        :return:
        """
        self.send_text_wait(email, Share.fill_email)
        self.send_text_wait(position, Share.fill_position)
        self.send_text_wait(dept, Share.fill_dept)
        self.click(Share.submit_btn)
        time.sleep(2)
        self.fill(self.es.fill_email, email, timeout=10)
        self.fill(self.es.fill_position, position)
        self.fill(self.es.fill_dept, dept)
        self.click(self.es.submit_btn)

    def fill_info_CIAQ(self, info):
        """
@@ -67,21 +45,21 @@
        :param info:
        :return:
        """
        self.send_text_wait(info["email"], Share.ciaq_email_input)
        self.selector(Share.ciaq_sex_select, Share.ciaq_sex_option, info["sex"])
        self.send_text_wait(info["age"], Share.ciaq_age_input)
        self.selector(Share.ciaq_grade_select, Share.ciaq_grade_option, info["grade"])
        self.send_text_wait(info["address"], Share.ciaq_address_input)
        self.send_text_wait(info["university"], Share.ciaq_university_input)
        self.send_text_wait(info["universityAddress"], Share.ciaq_universityAddress_input)
        self.send_text_wait(info["college"], Share.ciaq_college_input)
        self.send_text_wait(info["major"], Share.ciaq_major_input)
        self.selector(Share.ciaq_subject_select, Share.ciaq_subject_option, info["subject"])
        self.send_text_wait(info["GPA"], Share.ciaq_GPA_input)
        self.send_text_wait(info["work"], Share.ciaq_work_input)
        self.selector(Share.ciaq_status_select, Share.ciaq_status_option, info["status"])
        self.selector(Share.ciaq_workExperience_select, Share.ciaq_workExperience_option, info["workExperience"])
        self.click_wait(Share.submit_btn)
        self.send_text_wait(info["email"], self.es.ciaq_email_input)
        self.selector(self.es.ciaq_sex_select, self.es.ciaq_sex_option, info["sex"])
        self.send_text_wait(info["age"], self.es.ciaq_age_input)
        self.selector(self.es.ciaq_grade_select, self.es.ciaq_grade_option, info["grade"])
        self.send_text_wait(info["address"], self.es.ciaq_address_input)
        self.send_text_wait(info["university"], self.es.ciaq_university_input)
        self.send_text_wait(info["universityAddress"], self.es.ciaq_universityAddress_input)
        self.send_text_wait(info["college"], self.es.ciaq_college_input)
        self.send_text_wait(info["major"], self.es.ciaq_major_input)
        self.selector(self.es.ciaq_subject_select, self.es.ciaq_subject_option, info["subject"])
        self.send_text_wait(info["GPA"], self.es.ciaq_GPA_input)
        self.send_text_wait(info["work"], self.es.ciaq_work_input)
        self.selector(self.es.ciaq_status_select, self.es.ciaq_status_option, info["status"])
        self.selector(self.es.ciaq_workExperience_select, self.es.ciaq_workExperience_option, info["workExperience"])
        self.click_wait(self.es.submit_btn)

    def selector(self, select_loc, options_loc, text):
        """

 po/test_package_list_page.py

@@ -1,6 +1,7 @@
from base.base_page import BasePage
from selenium.webdriver.common.by import By
from elements.test_package_list_elements import TestPackageListElements as PackageList
from elements.test_package_list_elements import TestPackageListElements
from datetime import datetime
import time


@@ -9,66 +10,252 @@
    测试包列表页面
    """

    es = TestPackageListElements

    def __init__(self, driver):
        """初始化时将iframe切换到当前页面"""
        super().__init__(driver)
        try:
            self.driver.switch_to.default_content()
            self.switch_iframe(PackageList.this_iframe)
            self.switch_iframe(self.es.this_iframe)
        except:
            pass

    def create_btn(self):
    def create_package(self, data: dict):
        """
        点击创建按钮
        创建测试包
        :param data: 测试包参数
        :return:
        """
        self.click_wait(PackageList.create_btn)
        # 切换到add窗口的iframe
        self.switch_iframe(PackageList.add_iframe)
        # 点击创建按钮
        self.click(self.es.create_btn)
        # 切换到add的iframe
        self.switch_iframe(self.es.add_iframe)
        # 获取当前时间
        current_time = datetime.now()
        # 转换为字符串
        time_str = current_time.strftime("%Y%m%d%H%M%S")
        # 创建测试包填写的参数
        # 测试包名称
        test_package_name = data["product"] + "自动测试包-" + time_str
        # 填写测试包名称
        self.fill(self.es.add_testPackageName_input, test_package_name, timeout=10)
        # 填写报告企业名称
        self.fill(self.es.add_reportCompanyName_input, data["company"], timeout=10)
        # 选择测试包类型
        self.select(self.es.add_testPackageType_select, self.es.add_testPackageType_option, data["type"])
        # 选择区域
        self.select(self.es.add_testPackageArea_select, self.es.add_testPackageArea_option, data["area"])
        # 选择产品包
        self.prodTree_select(data["product"])
        # 输入hr邮箱
        self.fill(self.es.add_hrEmail_input, data["hrEmail"])
        # 输入有效期
        self.fill(self.es.add_invalidTime, data["invalid"])
        # 点击有效期输入框来隐藏日期选择器
        self.click(self.es.add_invalidTime)
        # 选择邀请邮件语言类型
        self.select(self.es.add_templateLangType_select, self.es.add_templateLangType_option, data["memberLang"])
        # 选择HR邮件语言类型
        self.select(self.es.add_hrTemplateLangType_select, self.es.add_hrTemplateLangType_option, data["hrReportLang"])
        # 选择报告模板
        self.select(self.es.add_reportTemplateId_select, self.es.add_reportTemplateId_option, data["reportTemplate"])

    def delete_package(self):
        # 判断是否为工作分析包
        if data["type"] == "工作分析包":
            # 如果是则填写
            # 输入要评价的岗位
            self.fill(self.es.add_position_input, data["position"])
            # 输入职业大类
            self.fill(self.es.add_professionalCategory_input, data["professionalCategory"])
            # 输入上级岗位
            self.fill(self.es.add_superiorPosition_input, data["superiorPosition"])

        # 点击测试者接收报告
        self.click(self.es.add_autoSendReport_checkbox)
        # 选择测试者报告邮箱语言类型
        self.select(self.es.add_memberReportLangType_select, self.es.add_memberReportLangType_option,
                    data["memberReportLang"])
        # 回到上一层iframe
        self.switch_parent_iframe()
        # 点击确认按钮
        self.click(self.es.add_confirm_btn)
        return test_package_name

    def edit_package(self, data: dict):
        """
        修改测试包
        :param data:
        :return:
        """
        # 切换到edit的iframe
        self.switch_iframe(self.es.edit_iframe)
        # 获取当前时间
        current_time = datetime.now()
        # 转换为字符串
        time_str = current_time.strftime("%Y%m%d%H%M%S")
        # 创建测试包填写的参数
        # 测试包名称
        test_package_name = data["product"] + "自动测试包-" + time_str
        # 填写测试包名称
        self.fill(self.es.add_testPackageName_input, test_package_name, timeout=10)
        # 填写报告企业名称
        self.fill(self.es.add_reportCompanyName_input, data["company"], timeout=10)
        # 选择区域
        self.select(self.es.add_testPackageArea_select, self.es.add_testPackageArea_option, data["area"])
        # 输入hr邮箱
        self.fill(self.es.add_hrEmail_input, data["hrEmail"])
        # 输入有效期
        self.fill(self.es.add_invalidTime, data["invalid"])
        # 点击有效期输入框来隐藏日期选择器
        self.click(self.es.add_invalidTime)
        # 选择邀请邮件语言类型
        self.select(self.es.add_templateLangType_select, self.es.add_templateLangType_option, data["memberLang"])
        # 选择HR邮件语言类型
        self.select(self.es.add_hrTemplateLangType_select, self.es.add_hrTemplateLangType_option, data["hrReportLang"])
        # 选择报告模板
        self.select(self.es.add_reportTemplateId_select, self.es.add_reportTemplateId_option, data["reportTemplate"])

        # 判断是否为工作分析包
        if data["type"] == "工作分析包":
            # 如果是则填写
            # 输入要评价的岗位
            self.fill(self.es.add_position_input, data["position"])
            # 输入职业大类
            self.fill(self.es.add_professionalCategory_input, data["professionalCategory"])
            # 输入上级岗位
            self.fill(self.es.add_superiorPosition_input, data["superiorPosition"])
        # 选择测试者报告邮箱语言类型
        self.select(self.es.add_memberReportLangType_select, self.es.add_memberReportLangType_option,
                    data["memberReportLang"])
        # 回到上一层iframe
        self.switch_parent_iframe()
        # 点击确认按钮
        self.click(self.es.edit_confirm_btn)
        return test_package_name

    def verify_edit_success(self, package_name, data):
        """
        验证修改是否成功
        :param package_name: 测试包名称
        :param data:
        :return:
        """
        # 勾选对应测试包
        self.select_package_checkbox(package_name)
        # 点击修改按钮
        self.click(self.es.edit_btn)
        time.sleep(2)
        # 切换到edit的iframe
        self.switch_iframe(self.es.edit_iframe)
        # 判断测试包名称
        flag = self.equals(self.es.add_testPackageName_input, package_name)
        if not flag:
            return flag
        # 判断报告企业名称
        flag = self.equals(self.es.add_reportCompanyName_input, data["company"])
        if not flag:
            return flag
        # 判断类型
        flag = self.equals(self.es.add_testPackageType_text, data["type"])
        if not flag:
            return flag
        # 判断区域
        flag = self.equals(self.es.add_testPackageArea_text, data["area"])
        if not flag:
            return flag
        # 判断产品包
        flag = self.equals(self.es.add_prodTree_input, data["product"])
        if not flag:
            return flag
        # 判断HR接收报告邮箱
        flag = self.equals(self.es.add_hrEmail_input, data["hrEmail"])
        if not flag:
            return flag
        # 判断有效期
        flag = self.equals(self.es.add_invalidTime, data["invalid"])
        if not flag:
            return flag

        # 判断语言类型
        text = "亲爱的"
        if data["memberLang"] == "English":
            text = "Dear"
        elif data["memberLang"] == "ไทย":
            text = "เรียน"
        # 判断测试者邀请内容
        flag = self.contains(self.es.add_templateLangType_text, text)
        if not flag:
            return flag

        # 判断语言类型
        text = "亲爱的"
        if data["hrReportLang"] == "English":
            text = "Dear HR Staff at"
        elif data["hrReportLang"] == "ไทย":
            text = "เรียนฝ่ายบุคคลของ"
        # 判断HR邮件内容
        flag = self.contains(self.es.add_hrTemplateLangType_text, text)
        if not flag:
            return flag

        # 判断报告模板
        flag = self.contains(self.es.add_reportTemplateId_text, data["reportTemplate"])
        if not flag:
            return flag

        # 判断是否为工作分析包
        if data["type"] == "工作分析包":
            # 判断要评价的岗位
            flag = self.equals(self.es.add_position_input, data["position"])
            if not flag:
                return flag
            # 判断职业大类
            flag = self.equals(self.es.add_professionalCategory_input, data["professionalCategory"])
            if not flag:
                return flag
            # 判断上级岗位
            flag = self.equals(self.es.add_superiorPosition_input, data["superiorPosition"])
            if not flag:
                return flag

        # 判断语言类型
        text = "亲爱的"
        if data["memberReportLang"] == "English":
            text = "Dear HR Staff at"
        elif data["memberReportLang"] == "ไทย":
            text = "เรียน"
        # 判断测试者
        flag = self.contains(self.es.add_memberReportLangType_text, text)
        if not flag:
            return flag

        # 判断人口学编码
        if "checkCode" in data:
            # 校验被勾选的人口选编码
            flag = self.verify_code_checked(data["checkCode"])
            if not flag:
                return flag
        if "uncheckCode" in data:
            # 校验被取消勾选的人口选编码
            flag = self.verify_code_unchecked(data["checkCode"])
            if not flag:
                return flag

        return flag


    def delete_package(self, package_name):
        """
        删除测试包
        :return:
        """
        # 勾选对应测试包
        self.select_package_checkbox(package_name)
        # 点击删除按钮
        self.click_wait(PackageList.delete_btn)
        self.click(self.es.delete_btn)
        # 点击确认按钮
        self.click_wait(PackageList.delete_confirm_btn)

    def testPackageName_input(self, testPackageName):
        """
        输入测试包名称
        :param testPackageName: 测试包名称
        :return:
        """
        self.send_text_wait(testPackageName, PackageList.add_testPackageName_input)

    def reportCompanyName_input(self, reportCompanyName):
        """
        输入报告企业名称
        :param reportCompanyName: 报告企业名称
        :return:
        """
        self.send_text_wait(reportCompanyName, PackageList.add_reportCompanyName_input)

    def testPackageType_select(self, testPackageType):
        """
        选择测试包类型
        :param testPackageType:
        :return:
        """
        # 点击下拉框
        self.click_wait(PackageList.add_testPackageType_select)
        # 获取所有选项
        options = self.get_elements_wait(PackageList.add_testPackageType_option)
        # 判断选项是否与传入的选项相等
        for opt in options:
            if opt.text == testPackageType:
                # 相等则点击该选项
                opt.click()
                break
        self.click(self.es.delete_confirm_btn)

    def prodTree_select(self, prodName):
        """
@@ -77,12 +264,11 @@
        :return:
        """
        # 点击查询按钮
        self.click_wait(PackageList.add_prodTree_btn)
        self.click(self.es.add_prodTree_btn)
        # 切换到prodTree的iframe
        self.switch_iframe_wait(PackageList.prodTree_iframe)
        time.sleep(2)
        self.switch_iframe_wait(self.es.prodTree_iframe)
        # 获取所有选项
        options = self.get_elements_wait(PackageList.prodTree_option)
        options = self.get_eles(self.es.prodTree_option, timeout=10)
        # 判断选项是否与传入选项相等
        for opt in options:
            if opt.text == prodName:
@@ -91,137 +277,7 @@
        # 切换到上一层的iframe
        self.switch_parent_iframe()
        # 点击确认按钮
        self.click_wait(PackageList.prodTree_confirm_btn)

    def hrReportEmail_input(self, hr_email):
        """
        输入HR接收报告邮箱
        :param hr_email:
        :return:
        """
        self.send_text_wait(hr_email, PackageList.add_hrEmail_input)

    def invalidTime_input(self, invalid_time):
        """
        输入有效期
        :param invalid_time:
        :return:
        """
        self.send_text_wait(invalid_time, PackageList.add_invalidTime)
        self.click_wait(PackageList.add_invalidTime)

    def testTemplateLangType_select(self, text):
        """
        选择测试者邀请邮件内容模板
        :param text: 语言类型，可以选择多个，使用 , 分隔
        :return:
        """
        # 分割text
        lang_types = text.split(",")
        # 点击下拉框
        self.click_wait(PackageList.add_templateLangType_select)
        # 获取所有选项
        options = self.get_elements_wait(PackageList.add_templateLangType_option)
        # 判断选项是否与传入的选项相等
        for opt in options:
            for lang_type in lang_types:
                if opt.text == lang_type:
                    # 相等则点击该选项
                    opt.click()
                    break

    def hrTemplateLangType_select(self, text):
        """
        选择HR邮件内容模板
        :param text: 语言类型，可以选择多个，使用 , 分隔
        :return:
        """
        # 分割text
        lang_types = text.split(",")
        # 点击下拉框
        self.click_wait(PackageList.add_hrTemplateLangType_select)
        # 获取所有选项
        options = self.get_elements_wait(PackageList.add_hrTemplateLangType_option)
        # 判断选项是否与传入的选项相等
        for opt in options:
            for lang_type in lang_types:
                if opt.text == lang_type:
                    # 相等则点击该选项
                    opt.click()
                    break

    def reportTemplate_select(self, text):
        """
        报告模板选择
        :param text: 模板，可以选择多个，使用 , 分隔
        :return:
        """
        # 分割text
        templates = text.split(",")
        # 点击下拉框
        self.click_wait(PackageList.add_reportTemplateId_select)
        # 获取所有选项
        options = self.get_elements_wait(PackageList.add_reportTemplateId_option)
        # 判断选项是否与传入的选项相等
        for opt in options:
            for template in templates:
                if opt.text == template:
                    # 相等则点击该选项
                    opt.click()
                    break
        # 再次点击下拉框
        self.click_wait(PackageList.add_reportTemplateId_select)

    def position_input(self, text):
        """
        输入要评价的岗位
        :param text:
        :return:
        """
        self.send_text_wait(text, PackageList.add_position_input)

    def professionalCategory_input(self, text):
        """
        输入职业大类
        :param text:
        :return:
        """
        self.send_text_wait(text, PackageList.add_professionalCategory_input)

    def superiorPosition_input(self, text):
        """
        输入上级岗位
        :param text:
        :return:
        """
        self.send_text_wait(text, PackageList.add_superiorPosition_input)

    def autoSendReport_checkbox(self):
        """
        点击测试者接收报告
        :return:
        """
        self.click_wait(PackageList.add_autoSendReport_checkbox)

    def memberReportLangType_select(self, text):
        """
        测试者报告邮件语言类型
        :param text: 语言类型，可以选择多个，使用 , 分隔
        :return:
        """
        # 分割text
        lang_types = text.split(",")
        # 点击下拉框
        self.click_wait(PackageList.add_memberTemplateLangType_select)
        # 获取所有选项
        options = self.get_elements_wait(PackageList.add_memberTemplateLangType_option)
        # 判断选项是否与传入的选项相等
        for opt in options:
            for lang_type in lang_types:
                if opt.text == lang_type:
                    # 相等则点击该选项
                    opt.click()
                    break
        self.click(self.es.prodTree_confirm_btn)

    def select_code_checkbox(self, check_text, uncheck_text):
        """
@@ -231,32 +287,23 @@
        :return:
        """
        # 获取所有人口选编码选框元素
        code_boxs = self.get_elements_wait(PackageList.add_code_checkbox)
        code_boxs = self.get_elements_wait(self.es.add_code_checkbox)

        # 将check_text分割
        code_check_texts = check_text.split(',')
        # 选择人口学编码
        for code_text in code_check_texts:
            for code_box in code_boxs:
                if code_text == code_box.text:
                    code_box.click()

        # 将check_text分割
        # 将uncheck_text分割
        code_uncheck_texts = uncheck_text.split(',')
        # 取消选择人口学编码
        for code_text in code_uncheck_texts:
            for code_box in code_boxs:
                if code_text == code_box.text:
                    code_box.click()



    def add_confirm(self):
        """
        点击确认按钮
        :return:
        """
        # 回到上一层iframe
        self.switch_parent_iframe()
        self.click_wait(PackageList.add_confirm_btn)

    def is_create_success(self, packageName):
        """
@@ -264,72 +311,101 @@
        :param packageName: 测试包名称
        :return: bool
        """
        names = self.get_elements_wait(PackageList.table_packageName_a)
        names = self.get_eles(self.es.table_packageName_a)
        for name in names:
            if name.text == packageName:
                return True
        return False

    def click_package_checkbox(self, packageName):
    def select_package_checkbox(self, packageName):
        """
        选中测试包，勾选对应测试包列表的复选框
        :param packageName: 测试包名称
        :return:
        """
        # 获取到table的所有tr
        table_trs = self.get_elements_wait(PackageList.table_package_tr)
        table_trs = self.get_eles(self.es.table_package_tr)
        for tr in table_trs:
            # 判断复选框是否为选中状态
            tr_class = tr.get_attribute("class")
            if tr_class == "selected":
                # 已点击直接退出循环
                continue
            # 测试包名称在tr中的定位
            package_name_loc = (By.XPATH, "td[2]/a")
            # 获取tr中的测试包名称
            tr_package_name = self.get_element_in(tr, package_name_loc).text
            tr_package_name = tr.find_element(*package_name_loc).text
            if tr_package_name == packageName:
                # 复选框在tr中的定位
                package_checkbox_loc = (By.XPATH, "td[1]/input")
                # 获取复选框元素
                tr_checkbox = self.get_element_in(tr, package_checkbox_loc)
                tr_checkbox = tr.find_element(*package_checkbox_loc)
                # 点击复选框
                tr_checkbox.click()
                break

    def click_share_1_btn(self):
    def click_package_name(self, packageName):
        """
        点击生成分享链接按钮
        点击包名称跳转页面
        :param packageName:
        :return:
        """
        self.click_wait(PackageList.share_1_btn)
        # 获取到所有测试包名称a标签
        package_names = self.get_eles(self.es.table_packageName_a)
        for name in package_names:
            if name.text == packageName:
                name.click()

    def get_share_url(self):
    def get_share_url(self, package_name):
        """
        获取分享链接
        :return: url
        """
        # 勾选测试包
        self.select_package_checkbox(package_name)
        # 点击生成分享链接按钮
        self.click(self.es.share_1_btn)
        # 切换到share的iframe中
        self.switch_iframe(PackageList.share_iframe)
        self.switch_iframe(self.es.share_iframe)
        # 获取url
        url = self.get_input_value_js(PackageList.share_url_input)
        url = self.get_value_js(self.es.share_url_input)
        # 退回上一层iframe
        self.switch_parent_iframe()
        # 点击关闭按钮
        self.click_wait(PackageList.share_cancel_btn)
        time.sleep(1)
        self.click(self.es.share_cancel_btn)
        time.sleep(2)
        return url

    def selector(self, click_loc, options_loc, text):
    def verify_code_checked(self, text: str):
        """
        通用选择器，直接调用选择下拉框选项
        :param click_loc: 点击后出现下拉选项的元素定位
        :param options_loc: 选项的元素定位
        :param text: 判断点击的文本
        校验人口学编码是否勾选
        :return:
        """
        # 点击下拉框
        self.click_wait(click_loc)
        # 获取所有选项
        options = self.get_elements_wait(options_loc)
        # 判断选项是否与传入的选项相等
        for opt in options:
            if opt.text == text:
                # 相等则点击该选项
                opt.click()
                break
        texts = text.split(",")
        # 获取到所有人口学编码的label
        eles = self.get_eles(self.es.add_code_checkbox)
        for ele in eles:
            for t in texts:
                if t == ele.text:
                    ele_class = ele.find_element(By.XPATH, "div").get_attribute("class")
                    # 如果class不包含checked则返回False
                    if "checked" not in ele_class:
                        return False


    def verify_code_unchecked(self, text: str):
        """
        校验人口学编码是否没有被勾选
        :return:
        """
        texts = text.split(",")
        # 获取到所有人口学编码的label
        eles = self.get_eles(self.es.add_code_checkbox)
        for ele in eles:
            for t in texts:
                if t== ele.text:
                    ele_class = ele.find_element(By.XPATH, "div").get_attribute("class")
                    # 如果class包含checked则返回False
                    if "checked" in ele_class:
                        return False


 report/report.html

@@ -253,10 +253,10 @@
}
</script>
    <h1>report.html</h1>
    <p>Report generated on 18-Jul-2023 at 17:34:03 by <a href="https://pypi.python.org/pypi/pytest-html">pytest-html</a> v3.2.0</p>
    <p>Report generated on 28-Jul-2023 at 16:53:13 by <a href="https://pypi.python.org/pypi/pytest-html">pytest-html</a> v3.2.0</p>
    <h2>Summary</h2>
    <p>5 tests ran in 133.54 seconds. </p>
    <p class="filter" hidden="true">(Un)check the boxes to filter the results.</p><input checked="true" class="filter" data-test-result="passed" hidden="true" name="filter_checkbox" onChange="filterTable(this)" type="checkbox"/><span class="passed">5 passed</span>, <input checked="true" class="filter" data-test-result="skipped" disabled="true" hidden="true" name="filter_checkbox" onChange="filterTable(this)" type="checkbox"/><span class="skipped">0 skipped</span>, <input checked="true" class="filter" data-test-result="failed" disabled="true" hidden="true" name="filter_checkbox" onChange="filterTable(this)" type="checkbox"/><span class="failed">0 failed</span>, <input checked="true" class="filter" data-test-result="error" disabled="true" hidden="true" name="filter_checkbox" onChange="filterTable(this)" type="checkbox"/><span class="error">0 errors</span>, <input checked="true" class="filter" data-test-result="xfailed" disabled="true" hidden="true" name="filter_checkbox" onChange="filterTable(this)" type="checkbox"/><span class="xfailed">0 expected failures</span>, <input checked="true" class="filter" data-test-result="xpassed" disabled="true" hidden="true" name="filter_checkbox" onChange="filterTable(this)" type="checkbox"/><span class="xpassed">0 unexpected passes</span>
    <p>19 tests ran in 567.35 seconds. </p>
    <p class="filter" hidden="true">(Un)check the boxes to filter the results.</p><input checked="true" class="filter" data-test-result="passed" hidden="true" name="filter_checkbox" onChange="filterTable(this)" type="checkbox"/><span class="passed">19 passed</span>, <input checked="true" class="filter" data-test-result="skipped" disabled="true" hidden="true" name="filter_checkbox" onChange="filterTable(this)" type="checkbox"/><span class="skipped">0 skipped</span>, <input checked="true" class="filter" data-test-result="failed" disabled="true" hidden="true" name="filter_checkbox" onChange="filterTable(this)" type="checkbox"/><span class="failed">0 failed</span>, <input checked="true" class="filter" data-test-result="error" disabled="true" hidden="true" name="filter_checkbox" onChange="filterTable(this)" type="checkbox"/><span class="error">0 errors</span>, <input checked="true" class="filter" data-test-result="xfailed" disabled="true" hidden="true" name="filter_checkbox" onChange="filterTable(this)" type="checkbox"/><span class="xfailed">0 expected failures</span>, <input checked="true" class="filter" data-test-result="xpassed" disabled="true" hidden="true" name="filter_checkbox" onChange="filterTable(this)" type="checkbox"/><span class="xpassed">0 unexpected passes</span>
    <h2>Results</h2>
    <table id="results-table">
      <thead id="results-table-head">
@@ -270,8 +270,8 @@
      <tbody class="passed results-table-row">
        <tr>
          <td class="col-result">Passed</td>
          <td class="col-name">testcase/test_ciaq.py::TestCIAQ::test_login[login]</td>
          <td class="col-duration">5.01</td>
          <td class="col-name">testcase/test_2package_list.py::TestPackageList::test_create_package[testPackageList]</td>
          <td class="col-duration">9.81</td>
          <td class="col-links"></td></tr>
        <tr>
          <td class="extra" colspan="4">
@@ -279,8 +279,8 @@
      <tbody class="passed results-table-row">
        <tr>
          <td class="col-result">Passed</td>
          <td class="col-name">testcase/test_ciaq.py::TestCIAQ::test_create_package[CIAQ]</td>
          <td class="col-duration">2.07</td>
          <td class="col-name">testcase/test_2package_list.py::TestPackageList::test_edit_package[testPackageList]</td>
          <td class="col-duration">10.59</td>
          <td class="col-links"></td></tr>
        <tr>
          <td class="extra" colspan="4">
@@ -288,8 +288,8 @@
      <tbody class="passed results-table-row">
        <tr>
          <td class="col-result">Passed</td>
          <td class="col-name">testcase/test_ciaq.py::TestCIAQ::test_open_url[CIAQ]</td>
          <td class="col-duration">17.20</td>
          <td class="col-name">testcase/test_2package_list.py::TestPackageList::test_add_member[memberDetail]</td>
          <td class="col-duration">10.96</td>
          <td class="col-links"></td></tr>
        <tr>
          <td class="extra" colspan="4">
@@ -297,8 +297,8 @@
      <tbody class="passed results-table-row">
        <tr>
          <td class="col-result">Passed</td>
          <td class="col-name">testcase/test_ciaq.py::TestCIAQ::test_answer</td>
          <td class="col-duration">101.78</td>
          <td class="col-name">testcase/test_2package_list.py::TestPackageList::test_edit_member[memberDetail]</td>
          <td class="col-duration">6.59</td>
          <td class="col-links"></td></tr>
        <tr>
          <td class="extra" colspan="4">
@@ -306,8 +306,134 @@
      <tbody class="passed results-table-row">
        <tr>
          <td class="col-result">Passed</td>
          <td class="col-name">testcase/test_ciaq.py::TestCIAQ::test_delete_package</td>
          <td class="col-duration">7.31</td>
          <td class="col-name">testcase/test_2package_list.py::TestPackageList::test_export_member[memberDetail]</td>
          <td class="col-duration">2.31</td>
          <td class="col-links"></td></tr>
        <tr>
          <td class="extra" colspan="4">
            <div class="empty log">No log output captured.</div></td></tr></tbody>
      <tbody class="passed results-table-row">
        <tr>
          <td class="col-result">Passed</td>
          <td class="col-name">testcase/test_2package_list.py::TestPackageList::test_export_url[memberDetail]</td>
          <td class="col-duration">1.13</td>
          <td class="col-links"></td></tr>
        <tr>
          <td class="extra" colspan="4">
            <div class="empty log">No log output captured.</div></td></tr></tbody>
      <tbody class="passed results-table-row">
        <tr>
          <td class="col-result">Passed</td>
          <td class="col-name">testcase/test_2package_list.py::TestPackageList::test_import[memberDetail]</td>
          <td class="col-duration">4.23</td>
          <td class="col-links"></td></tr>
        <tr>
          <td class="extra" colspan="4">
            <div class="empty log">No log output captured.</div></td></tr></tbody>
      <tbody class="passed results-table-row">
        <tr>
          <td class="col-result">Passed</td>
          <td class="col-name">testcase/test_2package_list.py::TestPackageList::test_send_email[memberDetail]</td>
          <td class="col-duration">8.24</td>
          <td class="col-links"></td></tr>
        <tr>
          <td class="extra" colspan="4">
            <div class="empty log">No log output captured.</div></td></tr></tbody>
      <tbody class="passed results-table-row">
        <tr>
          <td class="col-result">Passed</td>
          <td class="col-name">testcase/test_2package_list.py::TestPackageList::test_send_sms[memberDetail]</td>
          <td class="col-duration">9.00</td>
          <td class="col-links"></td></tr>
        <tr>
          <td class="extra" colspan="4">
            <div class="empty log">No log output captured.</div></td></tr></tbody>
      <tbody class="passed results-table-row">
        <tr>
          <td class="col-result">Passed</td>
          <td class="col-name">testcase/test_2package_list.py::TestPackageList::test_skip_report[memberDetail]</td>
          <td class="col-duration">5.16</td>
          <td class="col-links"></td></tr>
        <tr>
          <td class="extra" colspan="4">
            <div class="empty log">No log output captured.</div></td></tr></tbody>
      <tbody class="passed results-table-row">
        <tr>
          <td class="col-result">Passed</td>
          <td class="col-name">testcase/test_2package_list.py::TestPackageList::test_remove_member[memberDetail]</td>
          <td class="col-duration">1.87</td>
          <td class="col-links"></td></tr>
        <tr>
          <td class="extra" colspan="4">
            <div class="empty log">No log output captured.</div></td></tr></tbody>
      <tbody class="passed results-table-row">
        <tr>
          <td class="col-result">Passed</td>
          <td class="col-name">testcase/test_2package_list.py::TestPackageList::test_edit_prompt[testPackageList]</td>
          <td class="col-duration">368.04</td>
          <td class="col-links"></td></tr>
        <tr>
          <td class="extra" colspan="4">
            <div class="empty log">No log output captured.</div></td></tr></tbody>
      <tbody class="passed results-table-row">
        <tr>
          <td class="col-result">Passed</td>
          <td class="col-name">testcase/test_2package_list.py::TestPackageList::test_verify_member_status[testPackageList]</td>
          <td class="col-duration">5.39</td>
          <td class="col-links"></td></tr>
        <tr>
          <td class="extra" colspan="4">
            <div class="empty log">No log output captured.</div></td></tr></tbody>
      <tbody class="passed results-table-row">
        <tr>
          <td class="col-result">Passed</td>
          <td class="col-name">testcase/test_2package_list.py::TestPackageList::test_generate_export_report[testPackageList]</td>
          <td class="col-duration">26.83</td>
          <td class="col-links"></td></tr>
        <tr>
          <td class="extra" colspan="4">
            <div class="empty log">No log output captured.</div></td></tr></tbody>
      <tbody class="passed results-table-row">
        <tr>
          <td class="col-result">Passed</td>
          <td class="col-name">testcase/test_2package_list.py::TestPackageList::test_download_report[testPackageList]</td>
          <td class="col-duration">2.08</td>
          <td class="col-links"></td></tr>
        <tr>
          <td class="extra" colspan="4">
            <div class="empty log">No log output captured.</div></td></tr></tbody>
      <tbody class="passed results-table-row">
        <tr>
          <td class="col-result">Passed</td>
          <td class="col-name">testcase/test_2package_list.py::TestPackageList::test_export_report[testPackageList]</td>
          <td class="col-duration">20.38</td>
          <td class="col-links"></td></tr>
        <tr>
          <td class="extra" colspan="4">
            <div class="empty log">No log output captured.</div></td></tr></tbody>
      <tbody class="passed results-table-row">
        <tr>
          <td class="col-result">Passed</td>
          <td class="col-name">testcase/test_2package_list.py::TestPackageList::test_export_data[testPackageList]</td>
          <td class="col-duration">2.18</td>
          <td class="col-links"></td></tr>
        <tr>
          <td class="extra" colspan="4">
            <div class="empty log">No log output captured.</div></td></tr></tbody>
      <tbody class="passed results-table-row">
        <tr>
          <td class="col-result">Passed</td>
          <td class="col-name">testcase/test_2package_list.py::TestPackageList::test_hr_resend[testPackageList]</td>
          <td class="col-duration">30.40</td>
          <td class="col-links"></td></tr>
        <tr>
          <td class="extra" colspan="4">
            <div class="empty log">No log output captured.</div></td></tr></tbody>
      <tbody class="passed results-table-row">
        <tr>
          <td class="col-result">Passed</td>
          <td class="col-name">testcase/test_2package_list.py::TestPackageList::test_member_resend[testPackageList]</td>
          <td class="col-duration">37.73</td>
          <td class="col-links"></td></tr>
        <tr>
          <td class="extra" colspan="4">

 testcase/conftest.py

@@ -5,9 +5,23 @@
import pytest
import json
import os
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager


@pytest.fixture
@pytest.fixture(scope="session")
def driver(request):
    options = Options()
    options.debugger_address = "127.0.0.1:9222"
    # 初始化webdriver
    driver = webdriver.Chrome(options=options)
    request.addfinalizer(driver.quit)
    return driver


@pytest.fixture(scope="session")
def data_read(request) -> dict:
    """
    读取测试使用的数据
@@ -16,6 +30,8 @@
    """
    # 获取当前项目根路径
    root_path = os.getcwd()
    if "\\testcase" in root_path:
        root_path = root_path[0:root_path.rfind("\\testcase")]
    # 获取到要获取数据的键
    key = request.param
    # 读取数据

 testcase/test_2package_list.py

New file
@@ -0,0 +1,820 @@
import os
from datetime import datetime
import time
from selenium.webdriver.common.by import By
from selenium.common.exceptions import TimeoutException
from selenium.common.exceptions import NoSuchElementException

import pytest
from comm.comm import *
from comm.read_data import *
from comm.write_data import *
from selenium import webdriver
from po.login_page import LoginPage
from po.home_page import HomePage
from po.test_package_list_page import TestPackageListPage
from po.member_detail_page import MemberDetailPage
from po.report_page import ReportPage
from po.share_add_page import ShareAddPage
from po.maq_answer_page import MAQAnswerPage
from po.caq_answer_page import CAQAnswerPage
from comm.my_random import *


class TestPackageList:
    driver = None
    test_package_name = "MAQV2自动测试包-20230727155906"
    member_email = None

    @pytest.mark.parametrize('data_read', ["testPackageList"], indirect=True)
    def test_create_package(self, data_read: dict, driver):
        """
        创建测试包
        :param data_read: 读取数据
        :return:
        """
        # 创建home页面的对象
        home_page = HomePage(driver)
        # 点击左侧菜单进入页面
        home_page.menu_select(data_read["menu"])
        # 创建测试包列表页面的对象
        test_package_list = TestPackageListPage(driver)
        # 创建测试包并接收创建的测试包名称
        create_package_name = test_package_list.create_package(data_read["add"])
        # 赋值到类变量
        TestPackageList.test_package_name = create_package_name
        time.sleep(5)
        # 判断是否成功创建
        assert test_package_list.is_create_success(create_package_name)

    @pytest.mark.parametrize('data_read', ["testPackageList"], indirect=True)
    def test_edit_package(self, data_read: dict, driver):
        """
        修改测试包
        :return:
        """
        # 创建测试包列表页面的对象
        test_package_list = TestPackageListPage(driver)
        # 勾选新创建的测试包
        test_package_list.select_package_checkbox(TestPackageList.test_package_name)
        # 点击修改按钮
        test_package_list.click(test_package_list.es.edit_btn)
        # 获取修改数据
        edit_data = data_read["edit"]
        # 修改测试包
        test_package_name = test_package_list.edit_package(edit_data)
        TestPackageList.test_package_name = test_package_name
        time.sleep(5)
        # 校验是否修改成功
        flag = test_package_list.verify_edit_success(test_package_name, edit_data)
        # 切换到上一层iframe
        test_package_list.switch_parent_iframe()
        # 点击关闭按钮
        test_package_list.click(test_package_list.es.edit_cancel_btn)
        assert flag

    @pytest.mark.parametrize('data_read', ["memberDetail"], indirect=True)
    def test_add_member(self, data_read: dict, driver):
        """
        新增评测人员
        :param data_read:
        :param driver:
        :return:
        """
        # 创建测试包列表页面的对象
        test_package_list = TestPackageListPage(driver)
        # 点击测试包名称
        test_package_list.click_package_name(TestPackageList.test_package_name)
        time.sleep(5)
        # 创建测评人员名单页面对象
        member_detail = MemberDetailPage(driver)
        # 新增测评人员
        member_email = member_detail.add_member(data_read["add"])
        TestPackageList.member_email = member_email
        time.sleep(5)
        # 校验是否新增成功
        assert member_detail.is_create_success(member_email)

    @pytest.mark.parametrize('data_read', ["memberDetail"], indirect=True)
    def test_edit_member(self, data_read: dict, driver):
        """
        修改测评人员
        :param data_read:
        :param driver:
        :return:
        """
        # 创建测评人员名单页面对象
        member_detail = MemberDetailPage(driver)
        # 修改测评人员
        member_email = member_detail.edit_member(TestPackageList.member_email, data_read["edit"])
        TestPackageList.member_email = member_email
        time.sleep(5)
        # 校验是否修改成功
        assert member_detail.is_edit_success(TestPackageList.member_email, data_read["edit"])



    @pytest.mark.parametrize('data_read', ["memberDetail"], indirect=True)
    def test_export_member(self, data_read: dict, driver):
        """导出"""
        # 创建测评人员名单页面对象
        member_detail = MemberDetailPage(driver)
        # 获取当前项目根路径
        root_path = os.getcwd()
        # 拼接下载文件目录
        dir_path = root_path + r"\download"
        # 获取目录下所有文件
        old_file_names = []
        for filename in os.listdir(dir_path):
            if os.path.isfile(os.path.join(dir_path, filename)):
                old_file_names.append(filename)

        # 点击导出按钮
        member_detail.click(member_detail.es.export_btn)
        # 点击确认框确认
        member_detail.click(member_detail.es.layer_confirm_btn, timeout=10)
        i = 0
        while i < data_read["downloadWaitTime"]:
            # 获取目录下所有文件
            new_file_names = []
            for filename in os.listdir(dir_path):
                if os.path.isfile(os.path.join(dir_path, filename)):
                    new_file_names.append(filename)
            # 判断旧文件的数量与新文件的数量是否相同，相同则睡眠一秒
            if len(old_file_names) == len(new_file_names):
                time.sleep(1)
                i += 1
                continue
            else:
                # 否则直接退出循环
                break
        else:
            assert False
        assert True

    @pytest.mark.parametrize('data_read', ["memberDetail"], indirect=True)
    def test_export_url(self, data_read: dict, driver):
        """导出测试链接"""
        # 创建测评人员名单页面对象
        member_detail = MemberDetailPage(driver)
        # 获取当前项目根路径
        root_path = os.getcwd()
        # 拼接下载文件目录
        dir_path = root_path + r"\download"
        # 获取目录下所有文件
        old_file_names = []
        for filename in os.listdir(dir_path):
            if os.path.isfile(os.path.join(dir_path, filename)):
                old_file_names.append(filename)

        # 点击导出测试链接按钮
        member_detail.click(member_detail.es.export_url_btn)
        # 点击确认框确认
        member_detail.click(member_detail.es.layer_confirm_btn, timeout=10)
        i = 0
        while i < data_read["downloadWaitTime"]:
            # 获取目录下所有文件
            new_file_names = []
            for filename in os.listdir(dir_path):
                if os.path.isfile(os.path.join(dir_path, filename)):
                    new_file_names.append(filename)
            # 判断旧文件的数量与新文件的数量是否相同，相同则睡眠一秒
            if len(old_file_names) == len(new_file_names):
                time.sleep(1)
                i += 1
                continue
            else:
                # 否则直接退出循环
                break
        else:
            assert False
        assert True

    @pytest.mark.parametrize('data_read', ["memberDetail"], indirect=True)
    def test_import(self, data_read: dict, driver):
        """批量导入"""
        # 创建测评人员名单页面对象
        member_detail = MemberDetailPage(driver)
        # 获取当前项目根路径
        root_path = os.getcwd()
        # 拼接导入文件路径
        file_path = root_path + r"\import\member_import.xlsx"
        # 点击批量导入按钮
        member_detail.click(member_detail.es.import_btn)
        # 发送文件路径到文件上传输入框
        member_detail.fill(member_detail.es.import_input, file_path)
        time.sleep(2)
        # 点击导入按钮
        member_detail.click(member_detail.es.import_confirm_btn)
        time.sleep(2)
        # 判断是否导入成功
        try:
            member_detail.get_ele(member_detail.es.import_success_text, timeout=10)
            # 点击确认按钮
            member_detail.click(member_detail.es.layer_confirm_btn)
            assert True
        except TimeoutException:
            try:
                # 点击确认按钮，如果不存在则不点击
                member_detail.click(member_detail.es.layer_confirm_btn, timeout=10)
            except TimeoutException:
                pass
            assert False

    @pytest.mark.parametrize('data_read', ["memberDetail"], indirect=True)
    def test_send_email(self, data_read: dict, driver):
        """发送邮件"""
        # 创建测评人员名单页面对象
        member_detail = MemberDetailPage(driver)
        # 勾选table头复选框
        member_detail.click(member_detail.es.table_thead_checkbox)
        # 勾选不发送的测评人员
        member_detail.unselect_email_checkbox(TestPackageList.member_email)
        # 点击发送邮件按钮
        member_detail.click(member_detail.es.send_email_btn)
        # 点击确认按钮
        member_detail.click(member_detail.es.layer_confirm_btn, timeout=10)
        time.sleep(2)
        # 再次点击确认按钮
        member_detail.click(member_detail.es.layer_confirm_btn, timeout=10)
        # 点击查看发送状态按钮
        member_detail.click(member_detail.es.send_status_btn)
        time.sleep(5)
        # 切换到上一层iframe
        member_detail.switch_parent_iframe()
        # 切换到发送状态iframe
        member_detail.switch_iframe(member_detail.es.send_status_iframe)
        # 获取到所有tr列表
        trs = member_detail.get_eles(member_detail.es.send_status_table_tr)
        # 判断数量是否大于0
        if len(trs) > 0:
            assert True
        else:
            assert False
        # 删除发送任务
        # 勾选所有记录
        member_detail.click(member_detail.es.table_thead_checkbox)
        # 点击删除按钮
        member_detail.click(member_detail.es.delete_btn)
        # 点击确认按钮
        member_detail.click(member_detail.es.layer_confirm_btn, timeout=10)
        # 关闭标签
        # 创建home页面对象
        home = HomePage(driver)
        # 关闭发送状态页面
        home.close_tab(member_detail.es.tab_name_send_status)

    @pytest.mark.parametrize('data_read', ["memberDetail"], indirect=True)
    def test_send_sms(self, data_read: dict, driver):
        """发送短信"""
        # 创建测评人员名单页面对象
        member_detail = MemberDetailPage(driver)
        # 勾选table头复选框
        member_detail.click(member_detail.es.table_thead_checkbox)
        # 勾选不发送的测评人员
        member_detail.unselect_email_checkbox(TestPackageList.member_email)
        # 点击发送邮件按钮
        member_detail.click(member_detail.es.send_sms_btn)
        # 点击确认按钮
        member_detail.click(member_detail.es.layer_confirm_btn, timeout=10)
        time.sleep(2)
        # 再次点击确认按钮
        member_detail.click(member_detail.es.layer_confirm_btn, timeout=10)
        # 点击查看发送状态按钮
        member_detail.click(member_detail.es.send_status_btn)
        time.sleep(5)
        # 切换到上一层iframe
        member_detail.switch_parent_iframe()
        # 切换到发送状态iframe
        member_detail.switch_iframe(member_detail.es.send_status_iframe)
        # 获取到所有tr列表
        trs = member_detail.get_eles(member_detail.es.send_status_table_tr)
        # 判断数量是否大于0
        if len(trs) > 0:
            assert True
        else:
            assert False
        # 删除发送任务
        # 勾选所有记录
        member_detail.click(member_detail.es.table_thead_checkbox)
        # 点击删除按钮
        member_detail.click(member_detail.es.delete_btn)
        # 点击确认按钮
        member_detail.click(member_detail.es.layer_confirm_btn, timeout=10)
        # 关闭标签
        # 创建home页面对象
        home = HomePage(driver)
        # 关闭发送状态页面
        home.close_tab(member_detail.es.tab_name_send_status)

    @pytest.mark.parametrize('data_read', ["memberDetail"], indirect=True)
    def test_skip_report(self, data_read: dict, driver):
        """跳转查看报告页面"""
        # 创建测评人员名单页面对象
        member_detail = MemberDetailPage(driver)
        # 点击查看报告
        member_detail.click(member_detail.es.table_report_btn)
        time.sleep(5)
        # 返回上一层iframe
        member_detail.switch_parent_iframe()
        # 判断是否存在查看报告的iframe
        try:
            member_detail.get_ele(member_detail.es.report_iframe, timeout=10)
            # 关闭标签
            # 创建home页面对象
            home = HomePage(driver)
            # 关闭发送状态页面
            home.close_tab(member_detail.es.tab_name_send_status)
            assert True
        except TimeoutException:
            assert False

    @pytest.mark.parametrize('data_read', ["memberDetail"], indirect=True)
    def test_remove_member(self, data_read: dict, driver):
        """
        删除测评人员
        :param data_read:
        :param driver:
        :return:
        """
        # 创建测评人员名单页面对象
        member_detail = MemberDetailPage(driver)
        # 勾选table头复选框
        member_detail.click(member_detail.es.table_thead_checkbox)
        # 勾选不删除的测评人员
        member_detail.unselect_email_checkbox(TestPackageList.member_email)
        # 点击删除按钮
        member_detail.click(member_detail.es.delete_btn)
        # 点击删除确认按钮
        member_detail.click(member_detail.es.layer_confirm_btn, timeout=10)
        # 判断删除是否成功
        try:
            member_detail.wait_visible(member_detail.es.operate_success_layer)
            assert True
        except TimeoutException:
            assert False
        # 创建home页面对象
        home = HomePage(driver)
        # 关闭当前页面
        home.close_tab(member_detail.es.tab_name_member_detail)

    @pytest.mark.parametrize('data_read', ["testPackageList"], indirect=True)
    def test_edit_prompt(self, data_read: dict, driver):
        """事中提示语修改"""
        # 创建测试包列表页面的对象
        test_package_list = TestPackageListPage(driver)
        # 勾选新创建的测试包
        test_package_list.select_package_checkbox(TestPackageList.test_package_name)
        # 点击事中提示语按钮
        test_package_list.click(test_package_list.es.hint_btn)
        # 切换到iframe
        test_package_list.switch_iframe(test_package_list.es.hint_iframe)
        # 点击第四个输入框
        test_package_list.click(test_package_list.es.hint_textarea)
        # 修改内容
        test_package_list.fill(test_package_list.es.hint_modal_span, data_read["hint"])
        # 点击保存
        test_package_list.click(test_package_list.es.hint_modal_save_btn)
        # 返回上一层
        test_package_list.switch_parent_iframe()
        # 点击确认按钮
        test_package_list.click(test_package_list.es.layer_confirm_btn)
        # 判断操作成功弹窗是否存在
        flag = True
        try:
            test_package_list.get_ele(test_package_list.es.operate_success_layer, timeout=20)
        except TimeoutException:
            flag = False

        if flag:
            time.sleep(2)
            # 获取到分享链接
            url = test_package_list.get_share_url(TestPackageList.test_package_name)
            # 打开新标签页加载url
            test_package_list.goto_new_table(url)
            # 创建分享页面对象
            share_add = ShareAddPage(driver)
            # 填写信息提交并获取测试链接
            test_url = share_add.get_test_url(data_read["name"], data_read["email"])
            # 当前页面打开链接
            share_add.goto(test_url)
            # 点击提交按钮
            share_add.click(share_add.es.submit_btn, timeout=10)
            # 获取数据
            info = data_read["info"]
            # 填写基本信息并提交
            share_add.fill_info(data_read["email"], info["position"], info["dept"])
            # 创建answer对象
            answer_page = MAQAnswerPage(driver)
            # 开始答题
            flag = answer_page.answer(hint=data_read["hint"], question=data_read["question"]["MAQ"])
            # 答完题关闭当前标签页
            driver.close()
            # 切换到第一个标签页
            answer_page.switch_window(0)
            # 网络异常重新答题
            if flag == "网络异常":
                # 创建测试包列表页面的对象
                test_package_list = TestPackageListPage(driver)
                # 勾选新创建的测试包
                test_package_list.select_package_checkbox(TestPackageList.test_package_name)
                # 获取到分享链接
                url = test_package_list.get_share_url(TestPackageList.test_package_name)
                # 打开新标签页加载url
                test_package_list.goto_new_table(url)
                # 创建分享页面对象
                share_add = ShareAddPage(driver)
                # 填写信息提交并获取测试链接
                test_url = share_add.get_test_url(data_read["name"], data_read["email"])
                # 当前页面打开链接
                share_add.goto(test_url)
                # 点击提交按钮
                share_add.click(share_add.es.submit_btn, timeout=10)
                # 获取数据
                info = data_read["info"]
                # 填写基本信息并提交
                share_add.fill_info(data_read["email"], info["position"], info["dept"])
                # 创建answer对象
                answer_page = MAQAnswerPage(driver)
                # 开始答题
                flag = answer_page.answer(hint=data_read["hint"], question=data_read["question"]["MAQ"])
                # 答完题关闭当前标签页
                driver.close()
                # 切换到第一个标签页
                answer_page.switch_window(0)
            if flag is not None or not flag:
                assert flag

    @pytest.mark.parametrize('data_read', ["testPackageList"], indirect=True)
    def test_verify_member_status(self, data_read: dict, driver):
        """验证测评人员状态"""
        # 创建测试包列表页面的对象
        test_package_list = TestPackageListPage(driver)
        # 点击测试包名称
        test_package_list.click_package_name(TestPackageList.test_package_name)
        time.sleep(5)
        # 创建测评人员名单页面对象
        member_detail = MemberDetailPage(driver)
        # 获取列表
        tr = member_detail.get_eles(member_detail.es.table_data_tr)[0]
        # 获取当前日期
        now = datetime.now()
        # 提取年、月、日
        year = now.year
        month = now.month
        if month < 10:
            month = "0" + str(month)
        day = now.day
        if day < 10:
            day = "0" + str(day)
        # 拼接日期
        date = f"{year}-{month}-{day}"
        # 获取答题开始时间
        start_time = tr.find_element(By.XPATH, "td[6]").text
        # 获取答题结束时间
        end_time = tr.find_element(By.XPATH, "td[7]").text
        # 获取状态
        status = tr.find_element(By.XPATH, "td[12]/span").text
        # 验证
        if date in start_time and date in end_time and status == "完成":
            assert True
        else:
            assert False
        # 创建home页面对象
        home = HomePage(driver)
        # 关闭发送状态页面
        home.close_tab(member_detail.es.tab_name_member_detail)

    @pytest.mark.parametrize('data_read', ["testPackageList"], indirect=True)
    def test_generate_export_report(self, data_read: dict, driver):
        """重新生成并导出报告"""
        # 创建测试包列表页面的对象
        test_package_list = TestPackageListPage(driver)
        # 勾选测试包
        test_package_list.select_package_checkbox(TestPackageList.test_package_name)
        # 点击评测报告按钮
        test_package_list.click(test_package_list.es.report_btn)
        time.sleep(5)
        # 获取当前项目根路径
        root_path = os.getcwd()
        # 拼接下载文件目录
        dir_path = root_path + r"\download"
        # 获取目录下所有文件
        old_file_names = []
        for filename in os.listdir(dir_path):
            if os.path.isfile(os.path.join(dir_path, filename)):
                old_file_names.append(filename)

        # 创建report页面对象
        report = ReportPage(driver)
        # 勾选所有记录
        report.click(report.es.table_thead_checkbox)
        # 点击重新生成报告并导出
        report.click(report.es.generate_export_btn)
        time.sleep(2)
        while True:
            try:
                # 加载框存在睡眠一秒
                report.get_ele(report.es.layer_reload)
                time.sleep(1)
            except NoSuchElementException:
                # 不存在跳出循环
                break

        i = 0
        while i < data_read["downloadWaitTime"]:
            # 获取目录下所有文件
            new_file_names = []
            for filename in os.listdir(dir_path):
                if os.path.isfile(os.path.join(dir_path, filename)):
                    new_file_names.append(filename)
            # 判断旧文件的数量与新文件的数量是否相同，相同则睡眠一秒
            if len(old_file_names) == len(new_file_names):
                time.sleep(1)
                i += 1
                continue
            else:
                # 否则直接退出循环
                break
        else:
            assert False
        assert True

    @pytest.mark.parametrize('data_read', ["testPackageList"], indirect=True)
    def test_download_report(self, data_read: dict, driver):
        """下载已生成报告"""
        # 获取当前项目根路径
        root_path = os.getcwd()
        # 拼接下载文件目录
        dir_path = root_path + r"\download"
        # 获取目录下所有文件
        old_file_names = []
        for filename in os.listdir(dir_path):
            if os.path.isfile(os.path.join(dir_path, filename)):
                old_file_names.append(filename)

        # 创建report页面对象
        report = ReportPage(driver)
        # 点击下载已生成报告
        report.click(report.es.download_report_btn)
        time.sleep(2)
        while True:
            try:
                # 加载框存在睡眠一秒
                report.get_ele(report.es.layer_reload)
                time.sleep(1)
            except NoSuchElementException:
                # 不存在跳出循环
                break

        i = 0
        while i < data_read["downloadWaitTime"]:
            # 获取目录下所有文件
            new_file_names = []
            for filename in os.listdir(dir_path):
                if os.path.isfile(os.path.join(dir_path, filename)):
                    new_file_names.append(filename)
            # 判断旧文件的数量与新文件的数量是否相同，相同则睡眠一秒
            if len(old_file_names) == len(new_file_names):
                time.sleep(1)
                i += 1
                continue
            else:
                # 否则直接退出循环
                break
        else:
            assert False
        assert True

    @pytest.mark.parametrize('data_read', ["testPackageList"], indirect=True)
    def test_export_report(self, data_read: dict, driver):
        """导出报告"""
        # 获取当前项目根路径
        root_path = os.getcwd()
        # 拼接下载文件目录
        dir_path = root_path + r"\download"
        # 获取目录下所有文件
        old_file_names = listdir(dir_path)
        # 创建report页面对象
        report = ReportPage(driver)
        # 点击下载已生成报告
        report.click(report.es.export_btn)
        time.sleep(2)

        # 等待加载框消失
        report.wait_layer_reload_hide()

        i = 0
        while i < data_read["downloadWaitTime"]:
            # 获取目录下所有文件
            new_file_names = listdir(dir_path)
            # 判断旧文件的数量与新文件的数量是否相同，相同则睡眠一秒
            if len(old_file_names) == len(new_file_names):
                time.sleep(1)
                i += 1
                continue
            else:
                # 否则直接退出循环
                break
        else:
            assert False
        assert True

    @pytest.mark.parametrize('data_read', ["testPackageList"], indirect=True)
    def test_export_data(self, data_read: dict, driver):
        """导出测试数据"""
        # 获取当前项目根路径
        root_path = os.getcwd()
        # 拼接下载文件目录
        dir_path = root_path + r"\download"
        # 获取目录下所有文件
        old_file_names = listdir(dir_path)
        # 创建report页面对象
        report = ReportPage(driver)
        # 点击导出测试数据按钮
        report.click(report.es.export_data_btn)
        time.sleep(2)

        # 等待加载框消失
        report.wait_layer_reload_hide()

        new_file_names = []

        i = 0
        while i < data_read["downloadWaitTime"]:
            # 获取目录下所有文件
            new_file_names = listdir(dir_path)
            # 判断旧文件的数量与新文件的数量是否相同，相同则睡眠一秒
            if len(old_file_names) == len(new_file_names):
                time.sleep(1)
                i += 1
                continue
            else:
                # 判断新的文件名是否包含未确认
                for file_name in new_file_names:
                    if "未确认" in file_name:
                        new_file_names = listdir(dir_path)
                        break
                else:
                    # 否则直接退出循环
                    break
        else:
            assert False

        # 获取两个列表中的差集
        result = set(old_file_names).symmetric_difference(set(new_file_names))
        result_list = list(result)
        file_name = dir_path + "\\" + result_list[0]
        # 读取文件数据
        data_list = read_excel(file_name, "Sheet1")
        # 导出的数据
        excel_data = data_list[3]
        # 答题的数据
        answer_data: dict = data_read["question"]["MAQ"]
        # 对比数据
        for key in answer_data.keys():
            if str(excel_data[key]) != str(excel_data[key]):
                print(key + "数据错误")
                # 创建report页面对象
                report = ReportPage(driver)
                home = HomePage(driver)
                # 关闭标签页
                home.close_tab(report.es.tab_name_report)
                assert False
        # 创建report页面对象
        report = ReportPage(driver)
        home = HomePage(driver)
        # 关闭标签页
        home.close_tab(report.es.tab_name_report)
        assert True

    @pytest.mark.parametrize('data_read', ["testPackageList"], indirect=True)
    def test_hr_resend(self, data_read: dict, driver):
        """HR邮件补发"""
        # 创建测试包列表页面的对象
        test_package_list = TestPackageListPage(driver)
        # 点击测试包名称
        test_package_list.click_package_name(TestPackageList.test_package_name)
        # 创建测评人员名单对象
        member = MemberDetailPage(driver)
        # 点击查看报告邮件发送记录
        member.click(member.es.report_send_log_btn)
        time.sleep(5)
        member.switch_parent_iframe()
        # 切换iframe
        member.switch_iframe(member.es.report_send_log_iframe)
        # 获取补发之前的重试次数
        before_resend_number = int(member.get_ele(member.es.resend_number_text).text)
        # 点击全选按钮
        member.click(member.es.table_thead_checkbox)
        # 点击HR邮件补发按钮
        member.click(member.es.hr_resend_btn)
        # 点击确认按钮
        member.click(member.es.layer_confirm_btn)
        time.sleep(2)
        # 等待加载完成
        while True:
            try:
                # 加载框存在睡眠一秒
                member.get_ele(member.es.layer_reload)
                time.sleep(1)
            except NoSuchElementException:
                # 不存在跳出循环
                break
        time.sleep(2)
        # 获取补发之后的重试次数
        after_resend_number = int(member.get_ele(member.es.resend_number_text).text)
        # 比较两次
        if before_resend_number + 1 == after_resend_number:
            assert True
        else:
            assert False

    @pytest.mark.parametrize('data_read', ["testPackageList"], indirect=True)
    def test_member_resend(self, data_read: dict, driver):
        """测试者邮件补发"""
        # 创建测评人员名单对象
        member = MemberDetailPage(driver)
        member.switch_parent_iframe()
        # 切换iframe
        member.switch_iframe(member.es.report_send_log_iframe)
        # 获取补发之前的重试次数
        before_resend_number = int(member.get_ele(member.es.resend_number_text).text)
        # 点击全选按钮
        member.click(member.es.table_thead_checkbox)
        # 点击测试者邮件补发按钮
        member.click(member.es.member_resend_btn)
        # 点击确认按钮
        member.click(member.es.layer_confirm_btn)
        time.sleep(2)
        # 等待加载完成
        while True:
            try:
                # 加载框存在睡眠一秒
                member.get_ele(member.es.layer_reload)
                time.sleep(1)
            except NoSuchElementException:
                # 不存在跳出循环
                break
        time.sleep(2)
        # 获取补发之后的重试次数
        after_resend_number = int(member.get_ele(member.es.resend_number_text).text)
        # 比较两次
        if before_resend_number + 1 == after_resend_number:
            assert True
        else:
            assert False
        home = HomePage(driver)
        # 关闭标签页
        home.close_tab(member.es.tab_name_report_send_log)
        home.close_tab(member.es.tab_name_member_detail)

    # @pytest.mark.parametrize('data_read', ["memberDetail"], indirect=True)
    # def test_recover_package(self, data_read: dict, driver):
    #     # 创建测试包列表页面的对象
    #     test_package_list = TestPackageListPage(driver)
    #     # 点击回收测试包按钮
    #     test_package_list.click(test_package_list.es.recover_btn)
    #     # 点击确认按钮
    #     test_package_list.click(test_package_list.es.layer_confirm_btn)
    #     time.sleep(2)
    #     # 再次点击确认按钮
    #     test_package_list.click(test_package_list.es.layer_confirm_btn)
    #     # 获取到分享链接
    #     url = test_package_list.get_share_url(TestPackageList.test_package_name)
    #     # 打开新标签页加载url
    #     test_package_list.goto_new_table(url)
    #     # 创建分享页面对象
    #     share_add = ShareAddPage(driver)
    #     # 填写信息提交并获取测试链接
    #     test_url = share_add.get_test_url(data_read["edit"]["name"], data_read["edit"]["email"])
    #     # 当前页面打开链接
    #     share_add.goto(test_url)
    #     # 判断是否能够获取到提交按钮
    #     try:
    #         share_add.get_ele(share_add.es.submit_btn, timeout=10)
    #         assert False
    #     except TimeoutException:
    #         assert True
    #
    #     # 关闭当前标签页
    #     driver.close()
    #     # 切换到第一个标签页
    #     share_add.switch_window(0)





if __name__ == '__main__':
    pytest.main(["-s", __file__])











 testcase/test_3export_test_data.py

New file
@@ -0,0 +1,124 @@
import os
from datetime import datetime
import time
from selenium.webdriver.common.by import By
from selenium.common.exceptions import TimeoutException
from selenium.common.exceptions import NoSuchElementException

import pytest
from comm.comm import *
from comm.read_data import *
from comm.write_data import *
from selenium import webdriver
from po.login_page import LoginPage
from po.home_page import HomePage
from po.export_test_data_page import ExportTestDataPage
from po.member_detail_page import MemberDetailPage
from po.report_page import ReportPage
from po.share_add_page import ShareAddPage
from po.maq_answer_page import MAQAnswerPage
from po.caq_answer_page import CAQAnswerPage
from comm.my_random import *


class TestPackageList:
    driver = None
    test_package_name = "MAQV2自动测试包-20230727155906"
    member_email = None

    @pytest.mark.parametrize('data_read', ["testPackageList"], indirect=True)
    def test_export_test_data(self, data_read: dict, driver):
        home = HomePage(driver)
        home.menu_select("测试包管理/导出测试数据")
        time.sleep(5)
        export = ExportTestDataPage(driver)
        # 选择产品包
        export.select(export.es.product_select, export.es.product_option, data_read["edit"]["product"])

        # 获取当前日期
        now = datetime.now()
        # 提取年、月、日
        year = now.year
        month = now.month
        if month < 10:
            month = "0" + str(month)
        day = now.day
        if day < 10:
            day = "0" + str(day)
        # 拼接日期
        date = f"{year}-{month}-{day}"
        # 输入完成时间
        export.fill(export.es.test_begin_time_input, date)
        export.fill(export.es.test_end_time_input, date)
        # 点击搜索按钮
        export.click(export.es.search_btn)
        time.sleep(5)

        # 获取当前项目根路径
        root_path = os.getcwd()
        # 拼接下载文件目录
        dir_path = root_path + r"\download"
        # 获取目录下所有文件
        old_file_names = listdir(dir_path)

        # 勾选
        export.click(export.es.table_thead_checkbox)
        # 点击导出
        export.click(export.es.export_test_data_btn)

        # 等待加载框消失
        export.wait_layer_reload_hide()

        new_file_names = []

        i = 0
        while i < data_read["downloadWaitTime"]:
            # 获取目录下所有文件
            new_file_names = listdir(dir_path)
            # 判断旧文件的数量与新文件的数量是否相同，相同则睡眠一秒
            if len(old_file_names) == len(new_file_names):
                time.sleep(1)
                i += 1
                continue
            else:
                # 判断新的文件名是否包含未确认
                for file_name in new_file_names:
                    if "未确认" in file_name:
                        new_file_names = listdir(dir_path)
                        break
                else:
                    # 否则直接退出循环
                    break
        else:
            assert False

        # 获取两个列表中的差集
        result = set(old_file_names).symmetric_difference(set(new_file_names))
        result_list = list(result)
        file_name = dir_path + "\\" + result_list[0]
        # 读取文件数据
        data_list = read_excel(file_name, "Sheet1")
        # 导出的数据
        excel_data = data_list[3]
        # 答题的数据
        answer_data: dict = data_read["question"]["MAQ"]
        # 对比数据
        for key in answer_data.keys():
            if excel_data[key] != answer_data[key]["answer"]:
                print(key + "数据错误")
                assert False
        assert True


if __name__ == '__main__':
    pytest.main(["-s", __file__])











 testcase/test_caq.py

@@ -1,6 +1,7 @@
from datetime import datetime
import time
from selenium.webdriver.common.by import By
from selenium.common.exceptions import TimeoutException

import pytest
from selenium import webdriver
@@ -16,149 +17,57 @@
    driver = None
    test_package_name = "CAQ自动测试包-20230718101350"

    @pytest.mark.parametrize('data_read', ["login"], indirect=True)
    def test_login(self, data_read: dict):
        """
        打开页面并进行登录测试
        :param data_read: 执行数据读取的函数并获取到返回值
        :return:
        """
        TestCAQ.driver = webdriver.Chrome()
        driver = TestCAQ.driver
        login_page = LoginPage(driver)
        try:
            # 打开链接
            driver.get(data_read["url"])
        except:
            # 链接打开出现异常说明链接无法访问,捕获异常但不做处理
            pass

        # 浏览器窗口最大化
        driver.maximize_window()
        # 获取到刷新按钮并每10秒点击一次,知道刷新按钮消失
        while True:
            try:
                # 判断打开的页面是否存在刷新按钮
                reload_btn = login_page.get_element((By.XPATH, "//div[@id='buttons']/div/button[@id='reload-button']"))
                # 点击刷新按钮
                reload_btn.click()
                time.sleep(10)
            except:
                # 出现异常表示不存在刷新按钮
                # 接着判断是否存在nginx error!
                try:
                    nginx_error = login_page.get_element((By.XPATH, "//strong[text() = 'nginx error!']"))
                    # 存在则睡眠10秒
                    time.sleep(10)
                except:
                    break

        login_page.login(data_read["username"], data_read["password"], data_read["code"])
        time.sleep(2)
        assert login_page.is_login_success()

    @pytest.mark.parametrize('data_read', ["CAQ"], indirect=True)
    def test_create_package(self, data_read: dict):
    def test_create_package(self, data_read: dict, driver):
        """
        创建测试包
        :param data_read: 读取数据
        :return:
        """
        # 获取driver
        driver = TestCAQ.driver
        # 创建home页面的对象
        home_page = HomePage(driver)
        # 点击左侧菜单进入页面
        home_page.menu_select(data_read["menu"])
        # 创建测试包列表页面的对象
        test_package_list = TestPackageListPage(driver)
        # 点击创建按钮
        test_package_list.create_btn()
        # 获取当前时间
        current_time = datetime.now()
        # 转换为字符串
        time_str = current_time.strftime("%Y%m%d%H%M%S")
        # 创建测试包填写的参数
        # 测试包名称
        test_package_name = "CAQ自动测试包-" + time_str
        # 设置测试包名称为类变量
        TestCAQ.test_package_name = test_package_name
        # 获取创建测试包的数据
        create_data = data_read["add"]
        # 填写测试包名称
        test_package_list.testPackageName_input(test_package_name)
        # 填写报告企业名称
        test_package_list.reportCompanyName_input(create_data["company"])
        # 选择测试包类型
        test_package_list.testPackageType_select(create_data["type"])
        # 选择产品包
        test_package_list.prodTree_select(create_data["product"])
        # 输入hr邮箱
        test_package_list.hrReportEmail_input(create_data["hrEmail"])
        # 输入有效期
        test_package_list.invalidTime_input(create_data["invalid"])
        # 选择邀请邮件语言类型
        test_package_list.testTemplateLangType_select(create_data["memberLang"])
        # 选择HR邮件语言类型
        test_package_list.hrTemplateLangType_select(create_data["hrReportLang"])
        # 选择报告模板
        test_package_list.reportTemplate_select(create_data["reportTemplate"])
        # 点击测试者接收报告
        test_package_list.autoSendReport_checkbox()
        # 选择测试者报告邮箱语言类型
        test_package_list.memberReportLangType_select(create_data["memberReportLang"])
        # 点击确认按钮
        test_package_list.add_confirm()
        time.sleep(2)
        # 判断是否成功创建
        assert test_package_list.is_create_success(test_package_name)
        # 创建测试包并接收创建的测试包名称
        create_package_name = test_package_list.create_package(data_read["add"])
        # 赋值到类变量
        TestCAQ.test_package_name = create_package_name
        time.sleep(5)
        # 判断是否成功创建
        assert test_package_list.is_create_success(create_package_name)

    @pytest.mark.parametrize('data_read', ["CAQ"], indirect=True)
    def test_open_url(self, data_read: dict):
    def test_open_url(self, data_read: dict, driver):
        """
        打开分享链接
        :return:
        """
        # 获取driver
        driver = TestCAQ.driver
        #     # 创建home页面的对象
        #     home_page = HomePage(driver)
        #     # 点击左侧菜单进入页面
        #     home_page.menu_select(data_read["menu"])
        # 创建测试包列表页面的对象
        test_package_list = TestPackageListPage(driver)
        # 勾选新创建的测试包
        test_package_list.click_package_checkbox(TestCAQ.test_package_name)
        # 点击生成分享链接按钮
        test_package_list.click_share_1_btn()
        # 获取到url
        url = test_package_list.get_share_url()
        # 获取到分享链接
        url = test_package_list.get_share_url(TestCAQ.test_package_name)
        # 打开新标签页加载url
        test_package_list.open_new_table_to_url(url)
        test_package_list.goto_new_table(url)
        # 创建分享页面对象
        share_add = ShareAddPage(driver)
        # 填写信息提交并获取测试链接
        name = random_string(8)
        email = name + "@gmail.com"
        test_url = share_add.page_default_operation(name, email)
        test_url = share_add.get_test_url(name, email)
        # 当前页面打开链接
        driver.get(test_url)
        share_add.goto(test_url)
        # 点击提交按钮
        share_add.submit_btn()
        share_add.click(share_add.es.submit_btn, timeout=10)
        # 获取数据
        info = data_read["info"]
        # 填写基本信息并提交
        share_add.fill_info(email, info["position"], info["dept"])
        time.sleep(5)

    def test_answer(self):
        # 获取driver
        driver = TestCAQ.driver
    def test_answer(self, driver):
        # 创建answer对象
        answer_page = CAQAnswerPage(driver)
        # 点击开始测试
        answer_page.start_btn()
        # 开始答题
        flag = answer_page.answer()
        # 答完题关闭当前标签页
@@ -169,14 +78,17 @@
            assert flag
            return

    def test_delete_package(self):
        # 获取driver
        driver = TestCAQ.driver
    def test_delete_package(self, driver):
        # 创建测试包列表页面的对象
        test_package_list = TestPackageListPage(driver)
        # 删除测试包
        test_package_list.delete_package()
        time.sleep(5)
        test_package_list.delete_package(TestCAQ.test_package_name)
        # 判断删除是否成功
        try:
            test_package_list.wait_visible(test_package_list.es.operate_success_layer)
            assert True
        except TimeoutException:
            assert False
        # 关闭
        driver.quit()


 testcase/test_group_report.py

New file
@@ -0,0 +1,147 @@
import os
from datetime import datetime
import time
from selenium.webdriver.common.by import By
from selenium.common.exceptions import TimeoutException
from selenium.common.exceptions import NoSuchElementException

import pytest
from comm.comm import *
from comm.read_data import *
from comm.write_data import *
from selenium import webdriver
from po.login_page import LoginPage
from po.home_page import HomePage
from po.group_report_page import GroupReportPage
from po.member_detail_page import MemberDetailPage
from po.report_page import ReportPage
from po.share_add_page import ShareAddPage
from po.maq_answer_page import MAQAnswerPage
from po.caq_answer_page import CAQAnswerPage
from comm.my_random import *


class TestGroupReport:
    driver = None
    name = "MAQV2自动测试包-20230727155906"
    member_email = None

    @pytest.mark.parametrize('data_read', ["groupReport"], indirect=True)
    def test_add(self, data_read: dict, driver):
        home = HomePage(driver)
        home.menu_select("测试包管理/组别报告")
        group = GroupReportPage(driver)
        # 点击新增按钮
        group.click(group.es.add_btn)
        # 切换iframe
        group.switch_iframe(group.es.add_iframe)
        # 获取随机名称
        name = "组别报告-" + random_string(8)
        TestGroupReport.name = name
        # 输入名称
        group.fill(group.es.add_name_input, name)
        # 文件路径
        # 获取当前项目根路径
        root_path = os.getcwd()
        # 拼接文件路径
        if "\\testcase" in root_path:
            root_path = root_path[0:root_path.rfind("\\testcase")]
        file_path = root_path + r"\data\MAQ_group_data.xlsx"
        # 传入文件
        group.fill(group.es.add_load_file_input, file_path)
        # 切换iframe
        group.switch_parent_iframe()
        # 点击确认按钮
        group.click(group.es.layer_confirm_btn)
        time.sleep(10)

    @pytest.mark.parametrize('data_read', ["testPackageList"], indirect=True)
    def test_group_data(self, data_read: dict, driver):
        group = GroupReportPage(driver)
        # 输入名称
        group.fill(group.es.add_name_input, TestGroupReport.name)
        # 点击搜索按钮
        group.click(group.es.search_btn)

        # 获取当前项目根路径
        root_path = os.getcwd()
        # 拼接下载文件目录
        if "\\testcase" in root_path:
            root_path = root_path[0:root_path.rfind("\\testcase")]
        dir_path = root_path + r"\download"
        # 获取目录下所有文件
        old_file_names = []
        for filename in os.listdir(dir_path):
            if os.path.isfile(os.path.join(dir_path, filename)):
                old_file_names.append(filename)

        # 点击组别数据
        group.click(group.es.group_data_btn)

        i = 0
        while i < data_read["downloadWaitTime"]:
            # 获取目录下所有文件
            new_file_names = []
            for filename in os.listdir(dir_path):
                if os.path.isfile(os.path.join(dir_path, filename)):
                    new_file_names.append(filename)
            # 判断旧文件的数量与新文件的数量是否相同，相同则睡眠一秒
            if len(old_file_names) == len(new_file_names):
                time.sleep(1)
                i += 1
                continue
            else:
                # 否则直接退出循环
                break
        else:
            assert False

    @pytest.mark.parametrize('data_read', ["testPackageList"], indirect=True)
    def test_group_report(self, data_read: dict, driver):
        group = GroupReportPage(driver)
        # 获取当前项目根路径
        root_path = os.getcwd()
        # 拼接下载文件目录
        if "\\testcase" in root_path:
            root_path = root_path[0:root_path.rfind("\\testcase")]
        dir_path = root_path + r"\download"
        # 获取目录下所有文件
        old_file_names = []
        for filename in os.listdir(dir_path):
            if os.path.isfile(os.path.join(dir_path, filename)):
                old_file_names.append(filename)

        # 点击组别数据
        group.click(group.es.group_report_btn)

        i = 0
        while i < data_read["downloadWaitTime"]:
            # 获取目录下所有文件
            new_file_names = []
            for filename in os.listdir(dir_path):
                if os.path.isfile(os.path.join(dir_path, filename)):
                    new_file_names.append(filename)
            # 判断旧文件的数量与新文件的数量是否相同，相同则睡眠一秒
            if len(old_file_names) == len(new_file_names):
                time.sleep(1)
                i += 1
                continue
            else:
                # 否则直接退出循环
                break
        else:
            assert False


if __name__ == '__main__':
    pytest.main(["-s", __file__])











 testcase/test_login.py

New file
@@ -0,0 +1,53 @@
from datetime import datetime
import time
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys

import pytest
from selenium import webdriver
from po.login_page import LoginPage
from po.home_page import HomePage
from po.test_package_list_page import TestPackageListPage
from po.share_add_page import ShareAddPage
from po.maq_answer_page import MAQAnswerPage
from comm.my_random import *


class TestLogin:
    driver = None

    @pytest.mark.parametrize('data_read', ["login"], indirect=True)
    def test_login(self, data_read: dict, driver):
        """
        打开页面并进行登录测试
        :param data_read: 执行数据读取的函数并获取到返回值
        :return:
        """
        login = LoginPage(driver)

        # 打开链接
        login.goto(data_read["url"])
        # 浏览器窗口最大化
        driver.maximize_window()
        # 通过标题判断是否访问正确
        while True:
            if driver.title == "OTS":
                # 标题等于OTS退出循环
                break
            else:
                # 标题不等于OTS休眠
                time.sleep(5)
        # 登录
        login.login(data_read["username"], data_read["password"], data_read["code"])
        # 断言登录是否成功
        assert login.login_assert()

    # def test_logout(self):
    #     driver = TestLogin.driver
    #     home = HomePage(driver)
    #     # 登出
    #     home.logout()


if __name__ == '__main__':
    pytest.main(["-s", __file__])

 testcase/test_maq.py

@@ -1,6 +1,7 @@
from datetime import datetime
import time
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys

import pytest
from selenium import webdriver
@@ -14,7 +15,7 @@

class TestMAQ:
    driver = None
    test_package_name = None
    test_package_name = "MAQ自动测试包-20230720170011"

    @pytest.mark.parametrize('data_read', ["login"], indirect=True)
    def test_login(self, data_read: dict):
@@ -53,7 +54,14 @@
                except:
                    break

        login_page.login(data_read["username"], data_read["password"], data_read["code"])
        # 输入用户名
        login_page.send_keys("username_ipt", data_read["username"])
        # 输入密码
        login_page.oper_elem("password_ipt", data_read["password"])
        # 输入验证码
        login_page.oper_elem("code_ipt", data_read["code"])
        # 点击登录按钮
        login_page.oper_elem("login_btn")
        time.sleep(2)
        assert login_page.is_login_success()

@@ -72,8 +80,13 @@
        home_page.menu_select(data_read["menu"])
        # 创建测试包列表页面的对象
        test_package_list = TestPackageListPage(driver)
        # 切换到测试包列表页面iframe
        test_package_list.oper_elem("this_iframe")
        time.sleep(2)
        # 点击创建按钮
        test_package_list.create_btn()
        test_package_list.oper_elem("create_btn")
        # 切换到添加窗口的iframe
        test_package_list.oper_elem("add_iframe")
        # 获取当前时间
        current_time = datetime.now()
        # 转换为字符串
@@ -86,33 +99,43 @@
        # 获取创建测试包的数据
        create_data = data_read["add"]
        # 填写测试包名称
        test_package_list.testPackageName_input(test_package_name)
        test_package_list.oper_elem("add_testPackageName_input", test_package_name)
        # 填写报告企业名称
        test_package_list.reportCompanyName_input(create_data["company"])
        test_package_list.oper_elem("add_reportCompanyName_input", create_data["company"])
        # 选择测试包类型
        test_package_list.testPackageType_select(create_data["type"])
        test_package_list.oper_elem("add_testPackageType_select", create_data["type"])
        # 点击产品包按钮
        test_package_list.oper_elem("add_prodTree_btn")
        # 切换到prodTree的iframe
        test_package_list.oper_elem("prodTree_iframe")
        # 选择产品包
        test_package_list.prodTree_select(create_data["product"])
        # 输入hr邮箱
        test_package_list.hrReportEmail_input(create_data["hrEmail"])
        # 输入有效期
        test_package_list.invalidTime_input(create_data["invalid"])
        # 选择邀请邮件语言类型
        test_package_list.testTemplateLangType_select(create_data["memberLang"])
        # 选择HR邮件语言类型
        test_package_list.hrTemplateLangType_select(create_data["hrReportLang"])
        # 选择报告模板
        test_package_list.reportTemplate_select(create_data["reportTemplate"])
        # 点击测试者接收报告
        test_package_list.autoSendReport_checkbox()
        # 选择测试者报告邮箱语言类型
        test_package_list.memberReportLangType_select(create_data["memberReportLang"])
        test_package_list.oper_elem("prodTree_option", create_data["product"])
        # 回到上一层iframe
        test_package_list.switch_parent_iframe()
        # 点击确认按钮
        test_package_list.add_confirm()
        time.sleep(2)
        test_package_list.oper_elem("prodTree_confirm_btn")
        # 输入hr邮箱
        test_package_list.oper_elem("add_hrEmail_input", create_data["hrEmail"])
        # 输入有效期并点击以取消日期选择器显示
        test_package_list.oper_elem("add_invalidTime_input", create_data["invalid"])
        test_package_list.oper_elem("add_invalidTime_btn")
        # 选择邀请邮件语言类型
        test_package_list.oper_elem("add_templateLangType_select", create_data["memberLang"])
        # 选择HR邮件语言类型
        test_package_list.oper_elem("add_hrTemplateLangType_select", create_data["hrReportLang"])
        # 选择报告模板
        test_package_list.oper_elem("add_reportTemplateId_select", create_data["reportTemplate"])
        # 点击测试者接收报告
        test_package_list.oper_elem("add_autoSendReport_checkbox")
        # 选择测试者报告邮箱语言类型
        test_package_list.oper_elem("add_memberTemplateLangType_select", create_data["memberReportLang"])
        # 切换到上一层iframe
        test_package_list.switch_parent_iframe()
        # 点击确认按钮
        test_package_list.oper_elem("add_confirm_btn")
        time.sleep(5)
        # 判断是否成功创建
        assert test_package_list.is_create_success(test_package_name)
        time.sleep(5)

    @pytest.mark.parametrize('data_read', ["MAQ"], indirect=True)
    def test_open_url(self, data_read: dict):
@@ -127,9 +150,16 @@
        # 勾选新创建的测试包
        test_package_list.click_package_checkbox(TestMAQ.test_package_name)
        # 点击生成分享链接按钮
        test_package_list.click_share_1_btn()
        test_package_list.oper_elem("share_1_btn")
        # 切换到分享窗口的iframe
        test_package_list.oper_elem("share_iframe")
        # 获取到url
        url = test_package_list.get_share_url()
        url = test_package_list.oper_elem("share_url_text")
        # 切换到上一层iframe
        test_package_list.switch_parent_iframe()
        # 点击关闭按钮
        test_package_list.oper_elem("share_cancel_btn")
        time.sleep(1)
        # 打开新标签页加载url
        test_package_list.open_new_table_to_url(url)
        # 创建分享页面对象
@@ -137,16 +167,24 @@
        # 填写信息提交并获取测试链接
        name = random_string(8)
        email = name + "@gmail.com"
        test_url = share_add.page_default_operation(name, email)
        # 填写邮箱和姓名并提交
        share_add.oper_elem("name_input", name)
        share_add.oper_elem("email_input", email)
        share_add.oper_elem("submit_btn")
        # 获取到测试链接
        test_url = share_add.oper_elem("test_url_text")
        # 当前页面打开链接
        driver.get(test_url)
        # 点击提交按钮
        share_add.submit_btn()
        share_add.oper_elem("submit_btn")
        # 获取数据
        info = data_read["info"]
        # 填写基本信息并提交
        share_add.fill_info(email, info["position"], info["dept"])
        time.sleep(5)
        share_add.oper_elem("fill_email_input", email)
        share_add.oper_elem("fill_position_input", info["position"])
        share_add.oper_elem("fill_dept_input", info["dept"])
        share_add.oper_elem("submit_btn")
        time.sleep(3)

    def test_answer(self):
        # 获取driver
@@ -154,13 +192,11 @@
        # 创建answer对象
        answer_page = MAQAnswerPage(driver)
        # 点击开始测试
        answer_page.start_btn()
        answer_page.oper_elem("start_btn")
        # 开始答题
        flag = answer_page.answer()
        # 答完题关闭当前标签页
        driver.close()
        # 切换到第一个标签页
        answer_page.switch_window(0)
        if flag is not None or not flag:
            assert flag
            return
@@ -170,9 +206,13 @@
        driver = TestMAQ.driver
        # 创建测试包列表页面的对象
        test_package_list = TestPackageListPage(driver)
        # 切换到第一个标签页
        test_package_list.switch_window(0)
        test_package_list.oper_elem("this_iframe")
        # 删除测试包
        test_package_list.delete_package()
        time.sleep(5)
        test_package_list.oper_elem("delete_btn")
        test_package_list.oper_elem("delete_confirm_btn")
        time.sleep(3)
        # 关闭
        driver.quit()


 testcase/test_product_accredit.py

New file
@@ -0,0 +1,78 @@
from datetime import datetime
import time
from selenium.webdriver.common.by import By
from selenium.common.exceptions import TimeoutException

import pytest
from selenium import webdriver
from po.login_page import LoginPage
from po.home_page import HomePage
from po.product_accredit_page import ProductAccreditPage
from po.test_package_list_page import TestPackageListPage
from po.share_add_page import ShareAddPage
from po.caq_answer_page import CAQAnswerPage
from comm.my_random import *


class TestProductAccredit:
    driver = None
    test_package_name = "CAQ自动测试包-20230718101350"

    @pytest.mark.parametrize('data_read', ["productAccredit"], indirect=True)
    def test_accredit(self, data_read: dict, driver):
        """
        产品包授权
        :param data_read: 读取数据
        :return:
        """
        # 创建home页面的对象
        home_page = HomePage(driver)
        # 点击左侧菜单进入页面
        home_page.menu_select(data_read["menu"])
        # 创建测试包列表页面的对象
        product = ProductAccreditPage(driver)
        # 搜索框输入账号
        product.fill(product.es.search_username_input, data_read["username"])
        # 点击搜索按钮
        product.click(product.es.search_btn)
        time.sleep(2)
        # 点击产品包授权按钮
        product.click(product.es.product_btn)
        time.sleep(2)
        # 切换iframe
        product.switch_iframe(product.es.accredit_iframe)
        # 选择产品包
        product.select(product.es.accredit_product_select, product.es.accredit_product_option, data_read["product"])
        product.click(product.es.accredit_temp_checkbox, timeout=10)
        # 点击产品包授权
        product.click(product.es.accredit_accredit_btn)
        time.sleep(2)
        product.switch_parent_iframe()
        # 点击确认按钮
        product.click(product.es.layer_confirm_btn)
        time.sleep(2)

        # 退出登录
        home = HomePage(driver)
        home.logout()
        time.sleep(5)
        # 登录
        login = LoginPage(driver)
        login.login(data_read["username"], data_read["password"], data_read["code"])
        # 点击菜单栏
        home = HomePage(driver)
        home.menu_select("测试包管理/测试包列表")
        # 创建测试包列表页面的对象
        test_package_list = TestPackageListPage(driver)
        # 创建测试包并接收创建的测试包名称
        create_package_name = test_package_list.create_package(data_read["add"])
        # 赋值到类变量
        TestProductAccredit.test_package_name = create_package_name
        time.sleep(5)
        # 判断是否成功创建
        assert test_package_list.is_create_success(create_package_name)



if __name__ == '__main__':
    pytest.main(["-s", __file__])

 testcase/test_vaq.py

@@ -1,7 +1,7 @@
from datetime import datetime
import time
from selenium.webdriver.common.by import By

from selenium.webdriver.chrome.options import Options
import pytest
from selenium import webdriver
from po.login_page import LoginPage
@@ -23,6 +23,8 @@
        :param data_read: 执行数据读取的函数并获取到返回值
        :return:
        """
        chrome_options = Options()
        chrome_options.add_argument("--headless")
        TestVAQ.driver = webdriver.Chrome()
        driver = TestVAQ.driver
        login_page = LoginPage(driver)