python一部分封装

#-*- coding:utf-8 -*-

# 倒包
from selenium import webdriver

# 导入休眠包
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

# 定义类继承单元测试
class FireFox(object):

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

        # 打开浏览器
        self.driver = webdriver.Firefox()
        # 设置最大化
        self.driver.maximize_window()
        # 大爱指定网站
        self.driver.get(url)
        # 设置休眠
        self.TimeSleep(ENUMS.FIVE_TIME)

        pass

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

        # 关闭
        self.driver.quit()

        pass

    # 静态休眠
    def TimeSleep(self,number):

        time.sleep(number)

        pass

    # 隐士休眠
    def TimeImplay(self,number):

        self.driver.implicitly_wait(number)

        pass

    # 查找控件方式 8 种
    def FindID(self,ID):

        # 使用显示休眠,一共休眠20秒,每隔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()

    # 输入内容
    def SendkeysID(self,ID,message):

        self.FindID(ID).send_keys(message)

    # 查找控件方式 8 种
    def FindName(self, name):
        # 使用显示休眠,一共休眠20秒,每隔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)

    # 根据id设置点击事件
    def ClickName(self, name):
        self.FindName(name).click()

    # 输入内容
    def SendkeysName(self, name, message):

        self.FindName(name).send_keys(message)

    # 查找控件方式 8 种
    def FindClass(self, cls):
        # 使用显示休眠,一共休眠20秒,每隔0.5秒休眠一次,

        clss = (By.CLASS_NAME, cls)

        # 休眠
        WebDriverWait(self.driver, ENUMS.TWENTY_TIME, ENUMS.ONE_HALF).until(EC.presence_of_element_located(clss))

        return self.driver.find_element_by_class_name(cls)

    # 根据id设置点击事件
    def ClickClass(self, cls):
        self.FindClass(cls).click()

    # 输入内容
    def SendkeysClass(self, cls, message):

        self.FindClass(cls).send_keys(message)

    # 查找控件方式 8 种
    def FindXpath(self, xpath):
        # 使用显示休眠,一共休眠20秒,每隔0.5秒休眠一次,

        xpaths = (By.XPATH, xpath)

        # 休眠
        WebDriverWait(self.driver, ENUMS.TWENTY_TIME, ENUMS.ONE_HALF).until(EC.presence_of_element_located(xpaths))

        return self.driver.find_element_by_xpath(xpath)

    # 根据id设置点击事件
    def ClickXpath(self, xpaht):

        self.FindXpath(xpaht).click()

    # 输入内容
    def SendkeysXpath(self, xpaht, message):

        self.FindXpath(xpaht).send_keys(message)

    # 查找控件方式 8 种
    def FindLink(self, link):
        # 使用显示休眠,一共休眠20秒,每隔0.5秒休眠一次,

        links = (By.LINK_TEXT, link)

        # 休眠
        WebDriverWait(self.driver, ENUMS.TWENTY_TIME, ENUMS.ONE_HALF).until(EC.presence_of_element_located(links))

        return self.driver.find_element_by_link_text(link)

    # 根据id设置点击事件
    def ClickLink(self, link):
        self.FindLink(link).click()

    # 输入内容
    def SendkeysLink(self, linl, message):
        self.FindLink(linl).send_keys(message)

    # 查找控件方式 8 种

    def FindPaty(self, link):
        # 使用显示休眠,一共休眠20秒,每隔0.5秒休眠一次,

        links = (By.PARTIAL_LINK_TEXT, link)

        # 休眠
        WebDriverWait(self.driver, ENUMS.TWENTY_TIME, ENUMS.ONE_HALF).until(EC.presence_of_element_located(links))

        return self.driver.find_element_by_partial_link_text(link)

        # 根据id设置点击事件

    def ClickPart(self, link):
        self.FindPaty(link).click()

        # 输入内容

    def SendkeysPart(self, linl, message):

        self.FindPaty(linl).send_keys(message)

    # 查找控件方式 8 种

    def FindTag(self, tag):
        # 使用显示休眠,一共休眠20秒,每隔0.5秒休眠一次,

        tags = (By.TAG_NAME, tag)

        # 休眠
        WebDriverWait(self.driver, ENUMS.TWENTY_TIME, ENUMS.ONE_HALF).until(EC.presence_of_element_located(tags))

        return self.driver.find_element_by_tag_name(tag)

        # 根据id设置点击事件

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

        # 输入内容

    def SendkeysTag(self, tag, message):

        self.FindTag(tag).send_keys(message)

    # 查找控件方式 8 种

    def FindCss(self, css):
        # 使用显示休眠,一共休眠20秒,每隔0.5秒休眠一次,

        csses = (By.CSS_SELECTOR, css)

        # 休眠
        WebDriverWait(self.driver, ENUMS.TWENTY_TIME, ENUMS.ONE_HALF).until(EC.presence_of_element_located(csses))

        return self.driver.find_elements_by_css_selector(css)

        # 根据id设置点击事件

    def ClickCss(self, css):

        self.FindCss(css).click()

        # 输入内容
    def SendkeysCss(self, css, message):

        self.FindCss(css).send_keys(message)

    # 获取title
    def getTitle(self):

        return self.driver.title

    # 获取当前窗口
    def getCurrent_Window(self):

        return self.driver.current_window_handle

    # 切换窗口的方法
    def switch_to_window(self,current):

        # 获取所有的窗口
        allwindows = self.driver.window_handles

        # 使用for循环进行切换
        for window in allwindows:

            if window != current:

                self.driver.switch_to.window(window)

    # 设置点击事件,以及切换窗口的封装
    def ClickID_Window(self,ID):

        # 获取当前窗口
        current_window = self.getCurrent_Window()
        # 进行点击
        self.ClickID(ID)
        # 休眠五秒
        self.TimeSleep(ENUMS.FIVE_TIME)
        # 切换窗口
        self.switch_to_window(current_window)

    # 设置点击事件,以及切换窗口的封装
    def ClickName_Window(self, name):
        # 获取当前窗口
        current_window = self.getCurrent_Window()
        # 进行点击
        self.ClickName(name)
        # 休眠五秒
        self.TimeSleep(ENUMS.FIVE_TIME)
        # 切换窗口
        self.switch_to_window(current_window)

    # 设置点击事件,以及切换窗口的封装
    def ClickClass_Window(self, cls):
        # 获取当前窗口
        current_window = self.getCurrent_Window()
        # 进行点击
        self.ClickClass(cls)
        # 休眠五秒
        self.TimeSleep(ENUMS.FIVE_TIME)
        # 切换窗口
        self.switch_to_window(current_window)

    # 设置点击事件,以及切换窗口的封装
    def ClickXpath_Window(self, xpath):
        # 获取当前窗口
        current_window = self.getCurrent_Window()
        # 进行点击
        self.ClickXpath(xpath)
        # 休眠五秒
        self.TimeSleep(ENUMS.FIVE_TIME)
        # 切换窗口
        self.switch_to_window(current_window)

    # 设置点击事件,以及切换窗口的封装

    def ClickTag_Window(self, tag):
        # 获取当前窗口
        current_window = self.getCurrent_Window()
        # 进行点击
        self.ClickTag(tag)
        # 休眠五秒
        self.TimeSleep(ENUMS.FIVE_TIME)
        # 切换窗口
        self.switch_to_window(current_window)

    # 设置点击事件,以及切换窗口的封装

    def ClickCss_Window(self, css):
        # 获取当前窗口
        current_window = self.getCurrent_Window()
        # 进行点击
        self.ClickCss(css)
        # 休眠五秒
        self.TimeSleep(ENUMS.FIVE_TIME)
        # 切换窗口
        self.switch_to_window(current_window)

    # 设置点击事件,以及切换窗口的封装

    def ClickLink_Window(self, link):
        # 获取当前窗口
        current_window = self.getCurrent_Window()
        # 进行点击
        self.ClickLink(link)
        # 休眠五秒
        self.TimeSleep(ENUMS.FIVE_TIME)
        # 切换窗口
        self.switch_to_window(current_window)

    # 设置点击事件,以及切换窗口的封装

    def ClickPart_Window(self, part):

        # 获取当前窗口
        current_window = self.getCurrent_Window()
        # 进行点击
        self.ClickPart(part)
        # 休眠五秒
        self.TimeSleep(ENUMS.FIVE_TIME)
        # 切换窗口
        self.switch_to_window(current_window)

   

# 通过js定位当前窗口
    def switch_to_view_js_ID(self,ID):

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

        pass

    # 通过js定位当前窗口
    def switch_to_view_js_Name(self, name):
        # 执行 js
        self.driver.execute_script("arguments[0].scrollIntoView();", self.FindName(name))

        pass

    # 通过js定位当前窗口
    def switch_to_view_js_Class(self, cls):
        # 执行 js
        self.driver.execute_script("arguments[0].scrollIntoView();", self.FindClass(cls))

        pass

    # 通过js定位当前窗口
    def switch_to_view_js_Xpath(self, xpath):
        # 执行 js
        self.driver.execute_script("arguments[0].scrollIntoView();", self.FindXpath(xpath))

        pass

    # 通过js定位当前窗口
    def switch_to_view_js_Tag(self, tag):
        # 执行 js
        self.driver.execute_script("arguments[0].scrollIntoView();", self.FindTag(tag))

        pass

    # 通过js定位当前窗口
    def switch_to_view_js_css(self, css):

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

        pass

    # 通过js定位当前窗口
    def switch_to_view_js_link(self, link):
        # 执行 js
        self.driver.execute_script("arguments[0].scrollIntoView();", self.FindLink(link))

        pass

    # 通过js定位当前窗口
    def switch_to_view_js_part(self, part):
        # 执行 js
        self.driver.execute_script("arguments[0].scrollIntoView();", self.FindPaty(part))

        pass

    # 切换到frame ID
    def seitch_to_id_frame(self,ID):

        # 切换到frame里面
        self.driver.switch_to.frame(self.FindID(ID))
        # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
        pass

    # 切换到frame Name
    def seitch_to_name_frame(self, name):
        # 切换到frame里面
        self.driver.switch_to.frame(self.FindName(name))
        # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
        pass

    # 切换到frame Class
    def seitch_to_class_frame(self, cls):
        # 切换到frame里面
        self.driver.switch_to.frame(self.FindClass(cls))
        # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
        pass

    # 切换到frame xpath
    def seitch_to_xpath_frame(self, xpath):
        # 切换到frame里面
        self.driver.switch_to.frame(self.FindXpath(xpath))
        # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
        pass

    # 切换到frame tag
    def seitch_to_tag_frame(self, tag):
        # 切换到frame里面
        self.driver.switch_to.frame(self.FindTag(tag))
        # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
        pass

    # 切换到frame tag
    def seitch_to_css_frame(self, css):
        # 切换到frame里面
        self.driver.switch_to.frame(self.FindCss(css))
        # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
        pass

    # 封装断言, 查找控件,获取内容,断言前后是不是一致
    def AssertEquilClass(self,self1,cls,expect):

        # 查找控件,获取内容
        self.message = self.FindClass(cls).text
        # 进行断言
        self1.assertEqual(self.message,expect)

        pass

    # 通过 title去断言
    def AssertEquilTitle(self,self1,expect):

        # 设置休眠,在这里使用强制等待
        self.TimeSleep(ENUMS.FIVE_TIME)
        # 查找控件,获取内容
        self.message = self.getTitle()
        # 进行断言
        self1.assertEqual(self.message,expect)

        pass

# 定义一个枚举类
class ENUMS(Enum):

    # 二秒
    TWO_TIME = 2
    # 五秒
    FIVE_TIME = 5
    # 10 秒
    TEN_TIME = 10
    # 20 秒
    TWENTY_TIME = 20
    # 0.5 秒
    ONE_HALF = 0.5