测试封装类

最新推荐文章于 2022-10-16 09:27:10 发布
LSJ44
最新推荐文章于 2022-10-16 09:27:10 发布
阅读量489
点赞数 1
CC 4.0 BY-SA版权
本文链接：https://blog.youkuaiyun.com/LSJ44/article/details/79022743
本文介绍了一个针对Selenium WebDriver的高级封装实践，通过封装常用操作如元素查找、点击及输入等，提高了代码的健壮性和易用性。特别强调了等待策略的运用，以确保元素的正确加载。
摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >
#-*- coding:utf-8 -*-
#导包
from selenium import webdriver
#导入time包
import time
#导入枚举包
from enum import Enum
#导入休眠的包
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By

#工具类的封装元素
# 1: 首先遵循高内聚 低耦合的思想
# 高内聚 就是将有关联的代码封装在一个类里面,供外部类调用
# 低耦合 不相关的代码尽量封装在不同的类里面,相互之间的调用比较方便
# selenium 类封装的内容
# 1: 打开关闭浏览器
# 2: 三种休眠方式 1: 强制等待 2: 隐式休眠 3: 显式休眠
# 休眠方式有三种
# 1: 强制休眠  强制休眠,当代码执行到该句代码的时候,进行休眠,当休眠结束执行接写来的代码
# 2: 隐式休眠  隐式休眠,当窗口打开,开始计算休眠时间,这里指定的是浏览器的总共休眠时间,如果这里用到1毛,就在总休眠时间里面减去1秒
# 3: 显示休眠  显式休眠,可以设置指定的休眠时间,同时可以设置每隔几秒检查一次元素右没有加载,如果加载了,休眠时间就结束了

# 3: 8种查找单个类型的控件方式 id name class xpath css link tag partai_link 同时也有八种点击事件和8种输入
# 4: 8种查询一组的方式,与查询一个相比就是多个s,返回的是list列表 同时也有八种点击事件和8种输入
# 5: 切换窗口的方式,通过 八种方式点击同时切换窗口,分别封装一个获取当前的窗口的,获取所有窗口的,还有一个封装点击切换窗口
# 6: 切换 frame 的方式 也有八种
# 7: 使用 js定位的方式
# 8: 使用 js实现显示隐藏功能
# 9: 切出 frame的方式
# 10: 断言的封装
# 11: 获取表示的功能
# 12: 设置浏览器的宽度和高度
# 13: 浏览器的前进 和 后退
# 14: 鼠标事件
# 15: 键盘事件
# 16: alert conform prompt  alert 这是一个警告框,只有一个按钮, confrom 有两个按钮, prompt 可以输入内容,同时有两个按钮,同时能获取输入的内融
# 17: 下拉框的封装
# 18: 下载的封装
# 19:

# 面试问题: 做过二次封装吗?
# 最low的回答: 会不会? 会, 做过没有? 做过
# 做过,比如web端针对 selenium,封装,封装的原因就在写项目的时候提高容错率,比如查找控件,如果不封装,网速太慢,就会导致代码奔溃,包括,我一般封装成首先使用显示
# 休眠去查找元素,如果存在,我采去控件,这样很多错误就避免了,再比如,点击控件,我们一般首先查找控件,再进行点击,我直接点击






# 声明类 继承object
class chromeutil(object):

    #打开浏览器
    def chrome_start(self,url):

        # self 类本身的意思,在这里的意思就是将属性复制给类
        # python 基本类型有五种 NUmber list tupe 字典 string 类型
        # Number 类型有 : int float long complex复数类型
        # list 与 元祖的区别 : 元祖里面的数据是不能修改的,list 里面的数据可以修改,lsit标识符 [] 元祖()
        # 打开浏览器
        self.driver=webdriver.Chrome(executable_path="D:\google\Chrome\Application\chromedriver.exe")
        #设置最大化
        self.driver.maximize_window()
        #打开指定网页
        self.driver.get(url)
        #设置休眠时间
        self.TimeSleep(ENUMS.TWO_TIME)
        pass

    #关闭浏览器
    def chrome_close(self):

        self.driver.quit()

        pass
    #关闭当前网页
    def chrome_current(self):
        # 如果想关闭当前新建的窗口
        # 必须首先切换窗口到当前窗口,再调用关闭才是关闭当前网页
        # 如果跳转的是新窗口,而你没有切换窗口,关闭是上一个页面

        # 比如调用切窗口最后才能,调用关闭的方法
        self.driver.close()
        pass

    #强制休眠
    def TimeSleep(self,number):
        #休眠
        time.sleep(number)
        pass
    #隐式休眠
    def TimeImplay(self,number):

        self.driver.implicitly_wait(number)

        pass

    #开始查找控件
    def FindID(self,ID):

        # 使用显示休眠检查元素是不是存在,如果不存在继续休眠,每个0.5秒检查一次,如果存在就执行下面查找控件的代码
        ids=(By.ID,ID)
        #检查元素是不是存在
        WebDriverWait(self.driver,ENUMS.TWENTY_TIME,ENUMS.ONE_HALF).until(EC.presence_of_element_located(ids))
        #开始查找控件
        return self.driver.find_element_by_id(ID)
    #通过id点击
    def ClickID(self,ID):

        self.FindID(ID).click()

    #通过 id输入
    def SendkeysID(self,ID,message):

        #查找控件，首先清空数据，同时在输入内容
        self.FindID(ID).clear()

        self.FindID(ID).send_keys(message)

    #通过id获取控件内容
    def getIdText(self,ID):

        return self.FindID(ID).text

    #通过id判断控件是不是可见
    def isDispalyID(self,ID):

        return self.FindID(ID).is_displayed()

    #通过id判断控件有没有被选中
    def isSelectID(self,ID):

        return self.FindID(ID).is_selected()

    # 通过 id 判断 input 标签 是不是可编辑,返回true表示可以编辑,返回false表示不可见编辑
    def isEnableID(self,ID):

         return self.FindID(ID).is_enabled()

    #开始查找控件
    def FindName(self,name):
        # 使用显示休眠检查元素是不是存在,如果不存在继续休眠,每个0.5秒检查一次,如果存在就执行下面查找控件
        names=(By.NAME,name)
        #检查元素是不是存在
        WebDriverWait(self.driver,ENUMS.TWENTY_TIME,ENUMS.ONE_HALF).until(EC.presence_of_element_located(names))
        #开始查找控件
        return self.driver.find_element_by_name(name)

    #通过name点击
    def ClickName(self,name):
        self.FindName(name).click()

    #通过name输入
    def SendkeysName(self,name,message):
         self.FindName(name).send_keys(message)

    #通过name获取控件内容
    def getNameText(self,name):
        return self.FindName(name).text

    #通过name判断控件是不是可控
    def isDispalyName(self,name):
        return self.FindName(name).is_displayed()

    #通过name判断控件有没有被选中
    def isSelectName(self,name):
        return self.FindName(name).is_selected()
    # 通过 id 判断 input 标签 是不是可编辑,返回true表示可以编辑,返回false表示不可见编辑
    def isEnableName(self,name):
        return

    # 开始查找控件

    def FindClass(self, cls):
        # 使用显示休眠检查元素是不是存在,如果不存在继续休眠,每个0.5秒检查一次,如果存在就执行下面查找控件的代码
        ids = (By.CLASS_NAME, cls)
        # 检查元素是不是存在
        WebDriverWait(self.driver, ENUMS.TWENTY_TIME, ENUMS.ONE_HALF).until(EC.presence_of_element_located(ids))

        # 开始查找控件
        return self.driver.find_element_by_class_name(cls)

        # 通过 id 点击

    def ClickClass(self, cls):
        self.FindClass(cls).click()

        # 通过 id输入

    def SendkeysClass(self, cls, message):
        self.FindClass(cls).send_keys(message)

        # 通过 id 获取控件内容

    def getClassText(self, cls):

        return self.FindClass(cls).text

        # 通过 id判断 控件是不是可见

    def isDispalyClass(self, cls):

        return self.FindClass(cls).is_displayed()

        #  通过 id判断控件有没有被选中

    def isSelectClass(self, cls):

        return self.FindClass(cls).is_selected()

        # 通过 id 判断 input 标签 是不是可编辑,返回true表示可以编辑,返回false表示不可见编辑

    def isEnableClass(self, cls):

        return self.FindClass(cls).is_enabled()


    # 开始查找控件

    def FindXpath(self, cls):
        # 使用显示休眠检查元素是不是存在,如果不存在继续休眠,每个0.5秒检查一次,如果存在就执行下面查找控件的代码
        ids = (By.XPATH, cls)
        # 检查元素是不是存在
        WebDriverWait(self.driver, ENUMS.TWENTY_TIME, ENUMS.ONE_HALF).until(EC.presence_of_element_located(ids))

        # 开始查找控件
        return self.driver.find_element_by_xpath(cls)

        # 通过 id 点击

    def ClickXpath(self, cls):
        self.FindXpath(cls).click()

        # 通过 id输入

    def SendkeysXpath(self, cls, message):
        self.FindXpath(cls).send_keys(message)

        # 通过 id 获取控件内容

    def getXpathText(self, cls):

        return self.FindXpath(cls).text

        # 通过 id判断 控件是不是可见

    def isDispalyXpath(self, cls):

        return self.FindXpath(cls).is_displayed()

        #  通过 id判断控件有没有被选中

    def isSelectXpath(self, cls):

        return self.FindXpath(cls).is_selected()

        # 通过 id 判断 input 标签 是不是可编辑,返回true表示可以编辑,返回false表示不可见编辑

    def isEnableXpath(self, cls):

        return self.FindXpath(cls).is_enabled()

    # 开始查找控件

    def FindLink(self, cls):
        # 使用显示休眠检查元素是不是存在,如果不存在继续休眠,每个0.5秒检查一次,如果存在就执行下面查找控件的代码
        ids = (By.LINK_TEXT, cls)
        # 检查元素是不是存在
        WebDriverWait(self.driver, ENUMS.TWENTY_TIME, ENUMS.ONE_HALF).until(EC.presence_of_element_located(ids))
        # 开始查找控件
        return self.driver.find_element_by_link_text(cls)

        # 通过 id 点击

    def ClickLink(self, cls):
        self.FindLink(cls).click()

        # 通过 id输入

    def SendkeysLink(self, cls, message):
        self.FindLink(cls).send_keys(message)

        # 通过 id 获取控件内容

    def getLinkText(self, cls):

        return self.FindLink(cls).text

        # 通过 id判断 控件是不是可见

    def isDispalyLink(self, cls):

        return self.FindLink(cls).is_displayed()

        #  通过 id判断控件有没有被选中

    def isSelectLink(self, cls):

        return self.FindLink(cls).is_selected()

        # 通过 id 判断 input 标签 是不是可编辑,返回true表示可以编辑,返回false表示不可见编辑

    def isEnableLink(self, cls):

        return self.FindLink(cls).is_enabled()


    # 开始查找控件

    def FindTag(self, cls):
        # 使用显示休眠检查元素是不是存在,如果不存在继续休眠,每个0.5秒检查一次,如果存在就执行下面查找控件的代码
        ids = (By.TAG_NAME, cls)
        # 检查元素是不是存在
        WebDriverWait(self.driver, ENUMS.TWENTY_TIME, ENUMS.ONE_HALF).until(EC.presence_of_element_located(ids))

        # 开始查找控件
        return self.driver.find_element_by_tag_name(cls)

        # 通过 id 点击

    def ClickTag(self, cls):
        self.FindTag(cls).click()

        # 通过 id输入

    def SendkeysTag(self, cls, message):
        self.FindTag(cls).send_keys(message)

        # 通过 id 获取控件内容

    def getTagText(self, cls):

        return self.FindTag(cls).text

        # 通过 id判断 控件是不是可见

    def isDispalyTag(self, cls):

        return self.FindTag(cls).is_displayed()

        #  通过 id判断控件有没有被选中

    def isSelectTag(self, cls):

        return self.FindTag(cls).is_selected()

        # 通过 id 判断 input 标签 是不是可编辑,返回true表示可以编辑,返回false表示不可见编辑

    def isEnableTag(self, cls):

        return self.FindTag(cls).is_enabled()

    # 开始查找控件

    def FindPart(self, cls):
        # 使用显示休眠检查元素是不是存在,如果不存在继续休眠,每个0.5秒检查一次,如果存在就执行下面查找控件的代码
        ids = (By.PARTIAL_LINK_TEXT, cls)
        # 检查元素是不是存在
        WebDriverWait(self.driver, ENUMS.TWENTY_TIME, ENUMS.ONE_HALF).until(EC.presence_of_element_located(ids))

        # 开始查找控件
        return self.driver.find_element_by_partial_link_text(cls)

        # 通过 id 点击

    def ClickPart(self, cls):
        self.FindPart(cls).click()

        # 通过 id输入

    def SendkeysPart(self, cls, message):
        self.FindPart(cls).send_keys(message)

        # 通过 id 获取控件内容

    def getPartText(self, cls):

        return self.FindPart(cls).text

        # 通过 id判断 控件是不是可见

    def isDispalyPart(self, cls):

        return self.FindPart(cls).is_displayed()

        #  通过 id判断控件有没有被选中

    def isSelectPart(self, cls):

        return self.FindPart(cls).is_selected()

        # 通过 id 判断 input 标签 是不是可编辑,返回true表示可以编辑,返回false表示不可见编辑

    def isEnablePart(self, cls):

        return self.FindPart(cls).is_enabled()

    # 开始查找控件

    def FindCss(self, cls):
        # 使用显示休眠检查元素是不是存在,如果不存在继续休眠,每个0.5秒检查一次,如果存在就执行下面查找控件的代码
        ids = (By.CSS_SELECTOR, cls)
        # 检查元素是不是存在
        WebDriverWait(self.driver, ENUMS.TWENTY_TIME, ENUMS.ONE_HALF).until(EC.presence_of_element_located(ids))

        # 开始查找控件
        return self.driver.find_element_by_css_selector(cls)

        # 通过 id 点击

    def ClickCss(self, cls):
        self.FindCss(cls).click()

        # 通过 id输入

    def SendkeysCss(self, cls, message):
        self.FindCss(cls).send_keys(message)

        # 通过 id 获取控件内容

    def getCssText(self, cls):

        return self.FindCss(cls).text

        # 通过 id判断 控件是不是可见

    def isDispalyCss(self, cls):

        return self.FindCss(cls).is_displayed()

        #  通过 id判断控件有没有被选中

    def isSelectCss(self, cls):

        return self.FindCss(cls).is_selected()

        # 通过 id 判断 input 标签 是不是可编辑,返回true表示可以编辑,返回false表示不可见编辑

    def isEnableCss(self, cls):

        return self.FindCss(cls).is_enabled()

        # 开始查找控件
    def FindIds(self, cls):
        # 使用显示休眠检查元素是不是存在,如果不存在继续休眠,每个0.5秒检查一次,如果存在就执行下面查找控件的代码
        ids = (By.ID, cls)
        # 检查元素是不是存在
        WebDriverWait(self.driver, ENUMS.TWENTY_TIME, ENUMS.ONE_HALF).until(EC.presence_of_element_located(ids))
        # 开始查找控件
        return self.driver.find_elements_by_id(cls)

        # 通过 id 点击

    def ClickIDs(self, cls):
        self.FindIds(cls).click()

        # 通过 id输入
    def SendkeysIDs(self, cls, message):
        self.FindIds(cls).send_keys(message)

    # 开始查找控件
    def FindNames(self, cls):
        # 使用显示休眠检查元素是不是存在,如果不存在继续休眠,每个0.5秒检查一次,如果存在就执行下面查找控件的代码
        ids = (By.NAME, cls)
        # 检查元素是不是存在
        WebDriverWait(self.driver, ENUMS.TWENTY_TIME, ENUMS.ONE_HALF).until(EC.presence_of_element_located(ids))
        # 开始查找控件
        return self.driver.find_elements_by_name(cls)

        # 通过 id 点击
    def ClickNames(self, cls):
        self.FindNames(cls).click()

        # 通过 id输入
    def SendkeysNames(self, cls, message):
        self.FindNames(cls).send_keys(message)

        # 开始查找控件
    def FindClasses(self, cls):
        # 使用显示休眠检查元素是不是存在,如果不存在继续休眠,每个0.5秒检查一次,如果存在就执行下面查找控件的代码
        ids = (By.CLASS_NAME, cls)
        # 检查元素是不是存在
        WebDriverWait(self.driver, ENUMS.TWENTY_TIME, ENUMS.ONE_HALF).until(EC.presence_of_element_located(ids))
        # 开始查找控件
        return self.driver.find_elements_by_class_name(cls)

        # 通过 id 点击

    def ClickClasses(self, cls):
        self.FindClasses(cls).click()

        # 通过 id输入
    def SendkeysClasses(self, cls, message):
        self.FindClasses(cls).send_keys(message)

        # 开始查找控件
    def FindCsss(self, cls):
        # 使用显示休眠检查元素是不是存在,如果不存在继续休眠,每个0.5秒检查一次,如果存在就执行下面查找控件的代码
        ids = (By.CSS_SELECTOR, cls)
        # 检查元素是不是存在
        WebDriverWait(self.driver, ENUMS.TWENTY_TIME, ENUMS.ONE_HALF).until(EC.presence_of_element_located(ids))
        # 开始查找控件
        return self.driver.find_elements_by_css_selector(cls)

        # 通过 id 点击

    def ClickCsss(self, cls):
        self.FindCsss(cls).click()

        # 通过 id输入
    def SendkeysCsss(self, cls, message):
        self.FindCsss(cls).send_keys(message)

        # 开始查找控件
    def FindParts(self, cls):
        # 使用显示休眠检查元素是不是存在,如果不存在继续休眠,每个0.5秒检查一次,如果存在就执行下面查找控件的代码
        ids = (By.PARTIAL_LINK_TEXT, cls)
        # 检查元素是不是存在
        WebDriverWait(self.driver, ENUMS.TWENTY_TIME, ENUMS.ONE_HALF).until(EC.presence_of_element_located(ids))
        # 开始查找控件
        return self.driver.find_elements_by_partial_link_text(cls)

        # 通过 id 点击

    def ClickParts(self, cls):
        self.FindParts(cls).click()

        # 通过 id输入
    def SendkeysParts(self, cls, message):
        self.FindParts(cls).send_keys(message)
        # 开始查找控件
    def FindTags(self, cls):
        # 使用显示休眠检查元素是不是存在,如果不存在继续休眠,每个0.5秒检查一次,如果存在就执行下面查找控件的代码
        ids = (By.TAG_NAME, cls)
        # 检查元素是不是存在
        WebDriverWait(self.driver, ENUMS.TWENTY_TIME, ENUMS.ONE_HALF).until(EC.presence_of_element_located(ids))
        # 开始查找控件
        return self.driver.find_elements_by_tag_name(cls)

        # 通过 id 点击
    def ClickTags(self, cls):
        self.FindTags(cls).click()

        # 通过 id输入
    def SendkeysTags(self, cls, message):
        self.FindTags(cls).send_keys(message)
        # 开始查找控件
    def FindLinks(self, cls):
        # 使用显示休眠检查元素是不是存在,如果不存在继续休眠,每个0.5秒检查一次,如果存在就执行下面查找控件的代码
        ids = (By.LINK_TEXT, cls)
        # 检查元素是不是存在
        WebDriverWait(self.driver, ENUMS.TWENTY_TIME, ENUMS.ONE_HALF).until(EC.presence_of_element_located(ids))
        # 开始查找控件
        return self.driver.find_elements_by_link_text(cls)

        # 通过 id 点击

    def ClickLinks(self, cls):
        self.FindLinks(cls).click()

        # 通过 id输入
    def SendkeysLinks(self, cls, message):
        self.FindLinks(cls).send_keys(message)

    # 开始查找控件
    def FindXpaths(self, cls):
        # 使用显示休眠检查元素是不是存在,如果不存在继续休眠,每个0.5秒检查一次,如果存在就执行下面查找控件的代码
        ids = (By.XPATH, cls)
        # 检查元素是不是存在
        WebDriverWait(self.driver, ENUMS.TWENTY_TIME, ENUMS.ONE_HALF).until(EC.presence_of_element_located(ids))
        # 开始查找控件
        return self.driver.find_elements_by_xpath(cls)

        # 通过 id 点击

    def ClickXpaths(self, cls):
        self.FindXpaths(cls).click()

        # 通过 id输入

    def SendkeysXpaths(self, cls, message):
        self.FindXpaths(cls).send_keys(message)

    #切换窗口
    #获取当前窗口
    def getCurrentWindow(self):

        return self.driver.current_window_handle

    #获取所有的窗口，进行切换
    def switch_to_window(self,current_window):
        #设置休眠
        self.TimeSleep(ENUMS.TWO_TIME)
        #获取所有的窗口
        all_window=self.driver.window_handles
        #使用for循环进行切换
        for window in all_window:

            if window!=current_window:

                self.driver.switch_to.window(window)

    #通过id点击进行切换窗口的方法
    def ClickID_switch_to_window(self,ID):

        current_window=self.getCurrentWindow()
        #点击
        self.ClickID(ID)
        #切换
        self.switch_to_window(current_window)

    # 通过id点击进行切换窗口的方法
    def ClickName_switch_to_window(self, name):
        current_window = self.getCurrentWindow()
        # 点击
        self.ClickName(name)
        # 切换
        self.switch_to_window(current_window)

    # 通过id点击进行切换窗口的方法
    def ClickTag_switch_to_window(self, Tag):
        current_window = self.getCurrentWindow()
        # 点击
        self.ClickTag(Tag)
        # 切换
        self.switch_to_window(current_window)

    # 通过id点击进行切换窗口的方法
    def ClickClass_switch_to_window(self, clas):
        current_window = self.getCurrentWindow()
        # 点击
        self.ClickClass(clas)
        # 切换
        self.switch_to_window(current_window)

    # 通过id点击进行切换窗口的方法
    def ClickCss_switch_to_window(self, css):
        current_window = self.getCurrentWindow()
        # 点击
        self.ClickCss(css)
        # 切换
        self.switch_to_window(current_window)

    # 通过id点击进行切换窗口的方法
    def ClickLink_switch_to_window(self, link):
        current_window = self.getCurrentWindow()
        # 点击
        self.ClickLink(link)
        # 切换
        self.switch_to_window(current_window)

    # 通过id点击进行切换窗口的方法
    def ClickPark_switch_to_window(self, park):
        current_window = self.getCurrentWindow()
        # 点击
        self.ClickPart(park)
        # 切换
        self.switch_to_window(current_window)

    # 通过id点击进行切换窗口的方法
    def ClickXpath_switch_to_window(self, xpath):
        current_window = self.getCurrentWindow()
        # 点击
        self.ClickXpath(xpath)
        # 切换
        self.switch_to_window(current_window)
    #切换 frame
    def switch_to_frame_tag(self,tag):

        self.driver.switch_to.frame(self.FindTag(tag))

    # 切换 frame
    def switch_to_frame_id(self, ID):

        self.driver.switch_to.frame(self.FindID(ID))
    # 切换 frame
    def switch_to_frame_name(self, name):

        self.driver.switch_to.frame(self.FindName(name))
    # 切换 frame
    def switch_to_frame_css(self, css):

        self.driver.switch_to.frame(self.FindCss(css))

    # 切换 frame
    def switch_to_frame_link(self, link):
        self.driver.switch_to.frame(self.FindLink(link))

    # 切换 frame
    def switch_to_frame_park(self, park):
        self.driver.switch_to.frame(self.FindPart(park))
    # 切换 frame
    def switch_to_frame_xpath(self, xpath):
        self.driver.switch_to.frame(self.FindXpath(xpath))
    # 切换 frame
    def switch_to_frame_class(self, clas):
        self.driver.switch_to.frame(self.FindCsss(clas))

    #切出frame方法
    def checkout_frame(self):

        self.driver.switch_to.default_content()

    #执行js的定位到指定位置
    def exe_js_id(self,ID):

        self.driver.execute_script("arguments[0].scrollIntoView();",self.FindID(ID))

        pass

    # 执行js的定位到指定位置
    def exe_js_name(self, name):

        self.driver.execute_script("arguments[0].scrollIntoView();", self.FindName(name))

        pass
    # 执行js的定位到指定位置
    def exe_js_link(self, link):

        self.driver.execute_script("arguments[0].scrollIntoView();", self.FindLink(link))

        pass
    # 执行js的定位到指定位置
    def exe_js_tag(self, tag):

        self.driver.execute_script("arguments[0].scrollIntoView();", self.FindTag(tag))

        pass
    # 执行js的定位到指定位置
    def exe_js_class(self, clas):

        self.driver.execute_script("arguments[0].scrollIntoView();", self.FindClass(clas))

        pass
    # 执行js的定位到指定位置
    def exe_js_css(self, css):

        self.driver.execute_script("arguments[0].scrollIntoView();", self.FindCss(css))

        pass
    # 执行js的定位到指定位置
    def exe_js_park(self, park):

        self.driver.execute_script("arguments[0].scrollIntoView();", self.FindPart(park))

        pass
    # 执行js的定位到指定位置
    def exe_js_xpath(self, xpath):

        self.driver.execute_script("arguments[0].scrollIntoView();", self.FindXpath(xpath))

        pass
    # 获取title
    def getTitle(self):

        return self.driver.title

    # 断言
    # 断言title,注意断言是单元测试语法，如果我们在这里想封装断言,必须将单元测试的self对象传递过来
    def AssertTitle(self,self1,expect):

        self1.assertEqual(self.getTitle(),expect)

        pass

    # 断言控件内容，分为八种，通过id断言
    def AssertId(self,self1,expect,ID):

        self1.assertEqual(self.getIdText(ID),expect)

    def AssertClass(self,self1,expect,cls):

        self1.assertEqual(self.getClassText(cls),expect)

    def AssertName(self, self1, expect, name):

        self1.assertEqual(self.getNameText(name), expect)

    def AssertTag(self, self1, expect, tag):

        self1.assertEqual(self.getTagText(tag), expect)

    def AssertLink(self, self1, expect, link):

        self1.assertEqual(self.getLinkText(link), expect)

    def AssertCss(self, self1, expect, css):

        self1.assertEqual(self.getCssText(css), expect)

    def AssertPark(self, self1, expect, park):

        self1.assertEqual(self.getPartText(park), expect)

    def AssertXpath(self, self1, expect, xpath):

        self1.assertEqual(self.getXpathText(xpath), expect)




# 封装枚举类 就是为了方便以后不能设置时间,直接调用,
class ENUMS(Enum):
    # 两秒
    TWO_TIME = 2
    # 五秒
    FIVE_TIME = 5
    # 10 秒
    TEN_TIME = 10
    # 20 秒
    TWENTY_TIME = 20
    # 0.5 秒
    ONE_HALF = 0.5