Selenium基本二次封装

Selenium是一个用于Web应用程序自动化测试工具，可以直接运行在浏览器中，针对页元素来进行定位并模仿人为操作。在进行自动化测试的过程中，我们经常会重复执行很多脚本，语句以及方法，这时，我们可以讲常用的动作封装到一个类中，以便多次调用。

一，把显示等待封装到每一次的元素定位中

# 元素定位
def ElementLocalization(method, locator, Sign=True):
    '''
    :param method: 定位方式
    :param locator: 元素路径
    :param Sign: 定位失败是否跳过（True抛出异常，False跳过）
    '''
    try:         
        return AccordingWait(method, locator)
    except Exception as e:
        if Sign:
            raise e
        else:
            return False

# 显式等待
def AccordingWait(method, locator, total=3, interval=1):
    '''
    :param method: 定位方式
    :param locator: 元素路径
    :param total: 总共等待时间
    :param interval: 等待间隔
    :return: 元素定位路径
    '''
    Ele = WebDriverWait(driver, total, interval).until(
        ec.visibility_of_all_elements_located(
            (method, locator)
        )
    )
    return Ele

#---------测试定位元素---------
#对元素进行定位，超时时间为3秒，等待间隔为1秒，3秒后如果还未定位到元素则抛出异常
ElementLocalization(By.ID,'username')

在web自动化中，网络是影响自动化结果最大的因素。在元素还没加载出来的时候，我们就对元素进行定位通常就会报错，如果中间加上强制等待会大大增加自动化的时间成本，如果每一个地方都加上显示等待又会使代码冗余，并且难于维护，所以把显示等待封装到元素定位中。

二，基于元素定位ElementLocalization()衍生出的封装

#元素点击
def ElementClick(self,method,locator,Sign=True):
    '''
    :param method: 定位方式
    :param locator: 元素路径
    '''
    self.ElementLocalization(method,locator,Sign).click()
        
#输入文本
def ElementInput(self,method,locator,text,Sign=True):
    '''
    :param method: 定位方式
    :param locator: 元素路径
    :param text: 输入文本
    '''
    self.ElementLocalization(method,locator,Sign).send_keys(text)
   
#获取文本
def GetElementText(self,method,locator,Sign=True):
    '''
    :param method: 定位方式
    :param locator: 元素路径
    '''
    text = self.ElementLocalization(method, locator,Sign).text
    return text

三，满足简单web自动化项目的基本封装

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

from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as ec

class basepage(object):

    #构造函数
    def __init__(self,driver,time=3):
        '''
        :param driver: 传入WebDriver
        :param time: 隐式等待时间,默认3秒
        '''
        self.driver = driver
        self.driver.maximize_window()
        self.driver.implicitly_wait(time)

    #访问url
    def AccessUrl(self,url):
        self.driver.get(url)

    # 显式等待
    def AccordingWait(self, method, locator, node, total=3, interval=1):
        '''
        :param method: 定位方式
        :param locator: 元素路径
        :param node: 是否多路径
        :param total: 总共等待时间
        :param interval: 等待间隔
        :return: 元素定位路径
        '''
        if node == 'less':
            Ele = WebDriverWait(self.driver, total, interval).until(
                ec.visibility_of_element_located(
                    (method, locator)
                )
            )
            return Ele
        else:
            Ele = WebDriverWait(self.driver, total, interval).until(
                ec.visibility_of_all_elements_located(
                    (method, locator)
                )
            )
            return Ele

    #元素定位
    def ElementLocalization(self,method,locator,node='less',Sign=True):
        '''
        :param method: 定位方式
        :param locator: 元素路径
        :param Sign: 定位失败是否跳过（True抛出异常，False跳过）
        '''
        try:
            return self.AccordingWait(method,locator,node)
        except Exception as e:
            if Sign:
                raise
            else:
                return False

    #元素点击
    def ElementClick(self,method,locator,node='less',Sign=True):
        '''
        :param method: 定位方式
        :param locator: 元素路径
        '''
        self.ElementLocalization(method,locator,node,Sign).click()

    #输入文本
    def ElementInput(self,method,locator,text,node='less',Sign=True):
        '''
        :param method: 定位方式
        :param locator: 元素路径
        :param text: 输入文本
        '''
        self.ElementLocalization(method,locator,node,Sign).send_keys(text)

    #获取文本
    def GetElementText(self,method,locator,node='less',Sign=True):
        '''
        :param method: 定位方式
        :param locator: 元素路径
        '''
        text = self.ElementLocalization(method, locator,node,Sign).text
        return text

    # 清除文本
    def ClearElementText(self,method,locator,node='less',Sign=True):
        '''
        :param method: 定位方式
        :param locator: 元素路径
        '''
        local = self.ElementLocalization(method, locator,node,Sign)
        local.clear()

    #等待元素消失,消失后返回True
    def ExistenceWaite(self,method,locator,total=3,interval=1):
        '''
        :param method: 定位方式
        :param locator: 元素路径
        :param total: 总共等待时间
        :param interval: 等待间隔
        :return: bool
        '''
        try:
            WebDriverWait(self.driver,total,interval).until_not(
                ec.presence_of_element_located
                    (method,locator)
            )
        except Exception:
            return False
        return True

    #移动游标
    def MoveCursor(self,method,locator):
        '''
        :param method: 定位方式
        :param locator: 元素路径
        '''
        pass

    #切换iframe
    def ChangeFrame(self,num=0):
        '''
        :param num: 默认进入第一次iframe
        '''
        iframe = self.driver.find_elements_by_tag_name('iframe')[num]
        return self.driver.switch_to.frame(iframe)

    #释放iframe
    def ReleaseFrame(self):
        self.driver.switch_to.default_content()

    #判断元素是否存在
    def AreThere(self, method, locator,node='less'):
        '''
        :param method: 定位方式
        :param locator: 元素路径
        :param return: bool
        '''
        Flag = True
        try:
            self.ElementLocalization(method, locator,node)
            return Flag
        except:
            Flag = False
            return Flag

    #页面缩放
    def PageZoom(self,num=0.5):
        '''
        :param num: 缩放比例
        '''
        zoom = "document.body.style.zoom='{}'".format(num)
        self.driver.excute_script(zoom)

    #改变元素标签属性
    def ChangeAttribute(self,method,locator,value,txt,node='less',Sign=True):
        path = self.ElementLocalization(method,locator,node,Sign)
        js = 'arguments[0].{}="{}"'.format(value,txt)
        self.driver.execute_script(js,path)

    #内嵌滚动条滚动
    def DivRolling(self,classname,method='div',direction='left', num=0,num2=0):
        '''
        :param classname: 内嵌div的classname
        :param method: 内嵌windows/div
        :param direction: 滚动条滚动方向
        :param num: 左边距
        :param num2: 上边距
        '''
        try:
            if method == 'div':
                if direction == 'top':
                    js = 'document.getElementsByClassName("{}")[0].scrollTop=' \
                         '{}'.format(classname, num)
                    self.driver.execute_script(js)
                elif direction == 'left':
                    js = 'document.getElementsByClassName("{}")[0].scrollLeft=' \
                         '{}'.format(classname, num)
                    self.driver.execute_script(js)
                else:
                    pass
            if method == 'window':
                js = "window.scrollTo({},{})".format(num, num2)
                return self.driver.execute_script(js)
        except Exception as e:
            raise e

    #获取当前页面URL
    def GetUrl(self):
        return self.driver.current_url

    #切换到新的窗口句柄
    def ChangeHandle(self):
        # 获取当前所有句柄
        handles = self.driver.window_handles
        return self.driver.switch_to_window(handles[-1])

    def  LongitudinalRolling(self,num):
        js = "var q=document.getElementById('id').scrollTop="+num
        self.driver.execute_script(js)

    # 将x,y插入js字符串
    def Change_JS(self,x, y):
        js = "window.scrollTo(,);"
        str_js1 = list(js)
        scrollTo_x = str_js1.index(',')
        str_js1.insert(scrollTo_x, str(x))
        js1 = ''.join(str_js1)
        str_js2 = list(js1)
        scrollTo_y = str_js2.index(')')
        str_js2.insert(scrollTo_y, str(y))
        js2 = ''.join(str_js2)
        return js2

    # 通过坐标(x, y)控制横向和纵向滚动条
    def TransverseRolling(self,x, y):
        js = self.Change_JS(x, y)
        self.driver.execute_script(js)